| blob | cc98ede539484155e138c9276d8c08b0e77fc095 |
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 * When a table has no indexes, vacuum the FSM after every 8GB, approximately
108 * (it won't be exact because we only vacuum FSM after processing a heap page
109 * that has some removable tuples). When there are indexes, this is ignored,
110 * and we vacuum FSM after each index/heap cleaning pass.
111 */
112 #define VACUUM_FSM_EVERY_PAGES \
113 ((BlockNumber) (((uint64) 8 * 1024 * 1024 * 1024) / BLCKSZ))
115 /*
116 * Guesstimation of number of dead tuples per page. This is used to
117 * provide an upper limit to memory allocated when vacuuming small
118 * tables.
119 */
120 #define LAZY_ALLOC_TUPLES MaxHeapTuplesPerPage
122 /*
123 * Before we consider skipping a page that's marked as clean in
124 * visibility map, we must've seen at least this many clean pages.
125 */
126 #define SKIP_PAGES_THRESHOLD ((BlockNumber) 32)
128 /*
129 * Size of the prefetch window for lazy vacuum backwards truncation scan.
130 * Needs to be a power of 2.
131 */
132 #define PREFETCH_SIZE ((BlockNumber) 32)
134 /*
135 * DSM keys for parallel vacuum. Unlike other parallel execution code, since
136 * we don't need to worry about DSM keys conflicting with plan_node_id we can
137 * use small integers.
138 */
139 #define PARALLEL_VACUUM_KEY_SHARED 1
140 #define PARALLEL_VACUUM_KEY_DEAD_TUPLES 2
141 #define PARALLEL_VACUUM_KEY_QUERY_TEXT 3
142 #define PARALLEL_VACUUM_KEY_BUFFER_USAGE 4
143 #define PARALLEL_VACUUM_KEY_WAL_USAGE 5
145 /*
146 * Macro to check if we are in a parallel vacuum. If true, we are in the
147 * parallel mode and the DSM segment is initialized.
148 */
149 #define ParallelVacuumIsActive(vacrel) ((vacrel)->lps != NULL)
151 /* Phases of vacuum during which we report error context. */
153 {
154 VACUUM_ERRCB_PHASE_UNKNOWN,
155 VACUUM_ERRCB_PHASE_SCAN_HEAP,
156 VACUUM_ERRCB_PHASE_VACUUM_INDEX,
157 VACUUM_ERRCB_PHASE_VACUUM_HEAP,
158 VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
159 VACUUM_ERRCB_PHASE_TRUNCATE
162 /*
163 * LVDeadTuples stores the dead tuple TIDs collected during the heap scan.
164 * This is allocated in the DSM segment in parallel mode and in local memory
165 * in non-parallel mode.
166 */
168 {
171 /* List of TIDs of tuples we intend to delete */
172 /* NB: this list is ordered by TID address */
174 * ItemPointerData */
177 /* The dead tuple space consists of LVDeadTuples and dead tuple TIDs */
178 #define SizeOfDeadTuples(cnt) \
179 add_size(offsetof(LVDeadTuples, itemptrs), \
180 mul_size(sizeof(ItemPointerData), cnt))
181 #define MAXDEADTUPLES(max_size) \
182 (((max_size) - offsetof(LVDeadTuples, itemptrs)) / sizeof(ItemPointerData))
184 /*
185 * Shared information among parallel workers. So this is allocated in the DSM
186 * segment.
187 */
189 {
190 /*
191 * Target table relid and log level. These fields are not modified during
192 * the lazy vacuum.
193 */
194 Oid relid;
197 /*
198 * An indication for vacuum workers to perform either index vacuum or
199 * index cleanup. first_time is true only if for_cleanup is true and
200 * bulk-deletion is not performed yet.
201 */
205 /*
206 * Fields for both index vacuum and cleanup.
207 *
208 * reltuples is the total number of input heap tuples. We set either old
209 * live tuples in the index vacuum case or the new live tuples in the
210 * index cleanup case.
211 *
212 * estimated_count is true if reltuples is an estimated value. (Note that
213 * reltuples could be -1 in this case, indicating we have no idea.)
214 */
218 /*
219 * In single process lazy vacuum we could consume more memory during index
220 * vacuuming or cleanup apart from the memory for heap scanning. In
221 * parallel vacuum, since individual vacuum workers can consume memory
222 * equal to maintenance_work_mem, the new maintenance_work_mem for each
223 * worker is set such that the parallel operation doesn't consume more
224 * memory than single process lazy vacuum.
225 */
228 /*
229 * Shared vacuum cost balance. During parallel vacuum,
230 * VacuumSharedCostBalance points to this value and it accumulates the
231 * balance of each parallel vacuum worker.
232 */
233 pg_atomic_uint32 cost_balance;
235 /*
236 * Number of active parallel workers. This is used for computing the
237 * minimum threshold of the vacuum cost balance before a worker sleeps for
238 * cost-based delay.
239 */
240 pg_atomic_uint32 active_nworkers;
242 /*
243 * Variables to control parallel vacuum. We have a bitmap to indicate
244 * which index has stats in shared memory. The set bit in the map
245 * indicates that the particular index supports a parallel vacuum.
246 */
251 /* Shared index statistics data follows at end of struct */
254 #define SizeOfLVShared (offsetof(LVShared, bitmap) + sizeof(bits8))
255 #define GetSharedIndStats(s) \
256 ((LVSharedIndStats *)((char *)(s) + ((LVShared *)(s))->offset))
257 #define IndStatsIsNull(s, i) \
258 (!(((LVShared *)(s))->bitmap[(i) >> 3] & (1 << ((i) & 0x07))))
260 /*
261 * Struct for an index bulk-deletion statistic used for parallel vacuum. This
262 * is allocated in the DSM segment.
263 */
265 {
267 IndexBulkDeleteResult istat;
270 /* Struct for maintaining a parallel vacuum state. */
272 {
275 /* Shared information among parallel vacuum workers */
278 /* Points to buffer usage area in DSM */
281 /* Points to WAL usage area in DSM */
284 /*
285 * The number of indexes that support parallel index bulk-deletion and
286 * parallel index cleanup respectively.
287 */
294 {
295 /* Target heap relation and its indexes */
296 Relation rel;
299 /* useindex = true means two-pass strategy; false means one-pass */
302 /* Buffer access strategy and parallel state */
303 BufferAccessStrategy bstrategy;
306 /* Statistics from pg_class when we start out */
309 /* rel's initial relfrozenxid and relminmxid */
310 TransactionId relfrozenxid;
311 MultiXactId relminmxid;
312 TransactionId latestRemovedXid;
314 /* VACUUM operation's cutoff for pruning */
315 TransactionId OldestXmin;
316 /* VACUUM operation's cutoff for freezing XIDs and MultiXactIds */
317 TransactionId FreezeLimit;
318 MultiXactId MultiXactCutoff;
320 /* Error reporting state */
326 VacErrPhase phase;
328 /*
329 * State managed by lazy_scan_heap() follows
330 */
341 /* Statistics output by us, for table */
344 /* Statistics output by index AMs */
347 /* Instrumentation counters */
351 * table */
356 /* Struct for saving and restoring vacuum error information. */
358 {
359 BlockNumber blkno;
360 OffsetNumber offnum;
361 VacErrPhase phase;
364 /* elevel controls whole VACUUM's verbosity */
368 /* non-export function prototypes */
405 BlockNumber relblocks);
408 ItemPointer itemptr);
418 BlockNumber nblocks,
427 OffsetNumber offnum);
432 /*
433 * heap_vacuum_rel() -- perform VACUUM for one heap relation
434 *
435 * This routine vacuums a single heap, cleans out its indexes, and
436 * updates its relpages and reltuples statistics.
437 *
438 * At entry, we have already established a transaction and opened
439 * and locked the relation.
440 */
441 void
443 BufferAccessStrategy bstrategy)
444 {
446 PGRUsage ru0;
453 write_rate;
457 TransactionId xidFullScanLimit;
458 MultiXactId mxactFullScanLimit;
459 BlockNumber new_rel_pages;
460 BlockNumber new_rel_allvisible;
462 TransactionId new_frozen_xid;
463 MultiXactId new_min_multi;
464 ErrorContextCallback errcallback;
467 TransactionId OldestXmin;
468 TransactionId FreezeLimit;
469 MultiXactId MultiXactCutoff;
475 /* measure elapsed time iff autovacuum logging requires it */
477 {
481 {
484 }
485 }
489 else
503 /*
504 * We request an aggressive scan if the table's frozen Xid is now older
505 * than or equal to the requested Xid full-table scan limit; or if the
506 * table's minimum MultiXactId is older than or equal to the requested
507 * mxid full-table scan limit; or if DISABLE_PAGE_SKIPPING was specified.
508 */
510 xidFullScanLimit);
512 mxactFullScanLimit);
518 /* Set up high level stuff about rel */
531 /* Set cutoffs for entire VACUUM */
541 /* Save index names iff autovacuum logging requires it */
544 {
549 }
551 /*
552 * Setup error traceback support for ereport(). The idea is to set up an
553 * error context callback to display additional information on any error
554 * during a vacuum. During different phases of vacuum (heap scan, heap
555 * vacuum, index vacuum, index clean up, heap truncate), we update the
556 * error context callback to display appropriate information.
557 *
558 * Note that the index vacuum and heap vacuum phases may be called
559 * multiple times in the middle of the heap scan phase. So the old phase
560 * information is restored at the end of those phases.
561 */
567 /* Do the vacuuming */
570 /* Done with indexes */
573 /*
574 * Compute whether we actually scanned the all unfrozen pages. If we did,
575 * we can adjust relfrozenxid and relminmxid.
576 *
577 * NB: We need to check this before truncating the relation, because that
578 * will change ->rel_pages.
579 */
582 {
585 }
586 else
589 /*
590 * Optionally truncate the relation.
591 */
593 {
594 /*
595 * Update error traceback information. This is the last phase during
596 * which we add context information to errors, so we don't need to
597 * revert to the previous phase.
598 */
601 InvalidOffsetNumber);
603 }
605 /* Pop the error context stack */
608 /* Report that we are now doing final cleanup */
610 PROGRESS_VACUUM_PHASE_FINAL_CLEANUP);
612 /*
613 * Update statistics in pg_class.
614 *
615 * In principle new_live_tuples could be -1 indicating that we (still)
616 * don't know the tuple count. In practice that probably can't happen,
617 * since we'd surely have scanned some pages if the table is new and
618 * nonempty.
619 *
620 * For safety, clamp relallvisible to be not more than what we're setting
621 * relpages to.
622 *
623 * Also, don't change relfrozenxid/relminmxid if we skipped any pages,
624 * since then we don't know for certain that all tuples have a newer xmin.
625 */
637 new_rel_pages,
638 new_live_tuples,
639 new_rel_allvisible,
641 new_frozen_xid,
642 new_min_multi,
645 /* report results to the stats collector, too */
652 /* and log the action if appropriate */
654 {
660 {
661 StringInfoData buf;
672 {
677 }
679 /*
680 * This is pretty messy, but we split it up so that we can skip
681 * emitting individual parts of the message when not applicable.
682 */
685 {
686 /*
687 * While it's possible for a VACUUM to be both is_wraparound
688 * and !aggressive, that's just a corner-case -- is_wraparound
689 * implies aggressive. Produce distinct output for the corner
690 * case all the same, just in case.
691 */
693 msgfmt = _("automatic aggressive vacuum to prevent wraparound of table \"%s.%s.%s\": index scans: %d\n");
694 else
696 }
697 else
698 {
701 else
703 }
709 appendStringInfo(&buf, _("pages: %u removed, %u remain, %u skipped due to pins, %u skipped frozen\n"),
719 OldestXmin);
726 {
739 }
743 {
752 }
763 }
764 }
766 /* Cleanup index statistics and index names */
768 {
774 }
775 }
777 /*
778 * For Hot Standby we need to know the highest transaction id that will
779 * be removed by any change. VACUUM proceeds in a number of passes so
780 * we need to consider how each pass operates. The first phase runs
781 * heap_page_prune(), which can issue XLOG_HEAP2_CLEAN records as it
782 * progresses - these will have a latestRemovedXid on each record.
783 * In some cases this removes all of the tuples to be removed, though
784 * often we have dead tuples with index pointers so we must remember them
785 * for removal in phase 3. Index records for those rows are removed
786 * in phase 2 and index blocks do not have MVCC information attached.
787 * So before we can allow removal of any index tuples we need to issue
788 * a WAL record containing the latestRemovedXid of rows that will be
789 * removed in phase three. This allows recovery queries to block at the
790 * correct place, i.e. before phase two, rather than during phase three
791 * which would be after the rows have become inaccessible.
792 */
793 static void
795 {
796 /*
797 * Skip this for relations for which no WAL is to be written, or if we're
798 * not trying to support archive recovery.
799 */
803 /*
804 * No need to write the record at all unless it contains a valid value
805 */
809 }
811 /*
812 * lazy_scan_heap() -- scan an open heap relation
813 *
814 * This routine prunes each page in the heap, which will among other
815 * things truncate dead tuples to dead line pointers, defragment the
816 * page, and set commit status bits (see heap_page_prune). It also builds
817 * lists of dead tuples and pages with free space, calculates statistics
818 * on the number of live tuples in the heap, and marks pages as
819 * all-visible if appropriate. When done, or when we run low on space
820 * for dead-tuple TIDs, invoke vacuuming of indexes and reclaim dead line
821 * pointers.
822 *
823 * If the table has at least two indexes, we execute both index vacuum
824 * and index cleanup with parallel workers unless parallel vacuum is
825 * disabled. In a parallel vacuum, we enter parallel mode and then
826 * create both the parallel context and the DSM segment before starting
827 * heap scan so that we can record dead tuples to the DSM segment. All
828 * parallel workers are launched at beginning of index vacuuming and
829 * index cleanup and they exit once done with all indexes. At the end of
830 * this function we exit from parallel mode. Index bulk-deletion results
831 * are stored in the DSM segment and we update index statistics for all
832 * the indexes after exiting from parallel mode since writes are not
833 * allowed during parallel mode.
834 *
835 * If there are no indexes then we can reclaim line pointers on the fly;
836 * dead line pointers need only be retained until all index pointers that
837 * reference them have been killed.
838 */
839 static void
841 {
843 BlockNumber nblocks,
844 blkno;
845 HeapTupleData tuple;
846 BlockNumber empty_pages,
847 vacuumed_pages,
848 next_fsm_block_to_vacuum;
855 PGRUsage ru0;
857 BlockNumber next_unskippable_block;
860 StringInfoData buf;
862 PROGRESS_VACUUM_PHASE,
863 PROGRESS_VACUUM_TOTAL_HEAP_BLKS,
864 PROGRESS_VACUUM_MAX_DEAD_TUPLES
865 };
876 else
896 /* Initialize instrumentation counters */
908 /*
909 * Allocate the space for dead tuples. Note that this handles parallel
910 * VACUUM initialization as part of allocating shared memory space used
911 * for dead_tuples.
912 */
917 /* Report that we're scanning the heap, advertising total # of blocks */
923 /*
924 * Except when aggressive is set, we want to skip pages that are
925 * all-visible according to the visibility map, but only when we can skip
926 * at least SKIP_PAGES_THRESHOLD consecutive pages. Since we're reading
927 * sequentially, the OS should be doing readahead for us, so there's no
928 * gain in skipping a page now and then; that's likely to disable
929 * readahead and so be counterproductive. Also, skipping even a single
930 * page means that we can't update relfrozenxid, so we only want to do it
931 * if we can skip a goodly number of pages.
932 *
933 * When aggressive is set, we can't skip pages just because they are
934 * all-visible, but we can still skip pages that are all-frozen, since
935 * such pages do not need freezing and do not affect the value that we can
936 * safely set for relfrozenxid or relminmxid.
937 *
938 * Before entering the main loop, establish the invariant that
939 * next_unskippable_block is the next block number >= blkno that we can't
940 * skip based on the visibility map, either all-visible for a regular scan
941 * or all-frozen for an aggressive scan. We set it to nblocks if there's
942 * no such block. We also set up the skipping_blocks flag correctly at
943 * this stage.
944 *
945 * Note: The value returned by visibilitymap_get_status could be slightly
946 * out-of-date, since we make this test before reading the corresponding
947 * heap page or locking the buffer. This is OK. If we mistakenly think
948 * that the page is all-visible or all-frozen when in fact the flag's just
949 * been cleared, we might fail to vacuum the page. It's easy to see that
950 * skipping a page when aggressive is not set is not a very big deal; we
951 * might leave some dead tuples lying around, but the next vacuum will
952 * find them. But even when aggressive *is* set, it's still OK if we miss
953 * a page whose all-frozen marking has just been cleared. Any new XIDs
954 * just added to that page are necessarily newer than the GlobalXmin we
955 * computed, so they'll have no effect on the value to which we can safely
956 * set relfrozenxid. A similar argument applies for MXIDs and relminmxid.
957 *
958 * We will scan the table's last page, at least to the extent of
959 * determining whether it has tuples or not, even if it should be skipped
960 * according to the above rules; except when we've already determined that
961 * it's not worth trying to truncate the table. This avoids having
962 * lazy_truncate_heap() take access-exclusive lock on the table to attempt
963 * a truncation that just fails immediately because there are tuples in
964 * the last page. This is worth avoiding mainly because such a lock must
965 * be replayed on any hot standby, where it can be disruptive.
966 */
969 {
971 {
972 uint8 vmstatus;
975 next_unskippable_block,
978 {
981 }
982 else
983 {
986 }
988 next_unskippable_block++;
989 }
990 }
994 else
998 {
999 Buffer buf;
1000 Page page;
1001 OffsetNumber offnum,
1002 maxoff;
1004 hastup;
1007 Size freespace;
1014 /* see note above about forcing scanning of last page */
1015 #define FORCE_CHECK_PAGE() \
1016 (blkno == nblocks - 1 && should_attempt_truncation(vacrel, params))
1024 {
1025 /* Time to advance next_unskippable_block */
1026 next_unskippable_block++;
1028 {
1030 {
1031 uint8 vmskipflags;
1034 next_unskippable_block,
1037 {
1040 }
1041 else
1042 {
1045 }
1047 next_unskippable_block++;
1048 }
1049 }
1051 /*
1052 * We know we can't skip the current block. But set up
1053 * skipping_blocks to do the right thing at the following blocks.
1054 */
1057 else
1060 /*
1061 * Normally, the fact that we can't skip this block must mean that
1062 * it's not all-visible. But in an aggressive vacuum we know only
1063 * that it's not all-frozen, so it might still be all-visible.
1064 */
1067 }
1068 else
1069 {
1070 /*
1071 * The current block is potentially skippable; if we've seen a
1072 * long enough run of skippable blocks to justify skipping it, and
1073 * we're not forced to check it, then go ahead and skip.
1074 * Otherwise, the page must be at least all-visible if not
1075 * all-frozen, so we can set all_visible_according_to_vm = true.
1076 */
1078 {
1079 /*
1080 * Tricky, tricky. If this is in aggressive vacuum, the page
1081 * must have been all-frozen at the time we checked whether it
1082 * was skippable, but it might not be any more. We must be
1083 * careful to count it as a skipped all-frozen page in that
1084 * case, or else we'll think we can't update relfrozenxid and
1085 * relminmxid. If it's not an aggressive vacuum, we don't
1086 * know whether it was all-frozen, so we have to recheck; but
1087 * in this case an approximate answer is OK.
1088 */
1092 }
1094 }
1098 /*
1099 * If we are close to overrunning the available space for dead-tuple
1100 * TIDs, pause and do a cycle of vacuuming before we tackle this page.
1101 */
1104 {
1105 /*
1106 * Before beginning index vacuuming, we release any pin we may
1107 * hold on the visibility map page. This isn't necessary for
1108 * correctness, but we do it anyway to avoid holding the pin
1109 * across a lengthy, unrelated operation.
1110 */
1112 {
1115 }
1117 /* Work on all the indexes, then the heap */
1120 /* Remove tuples from heap */
1123 /*
1124 * Forget the now-vacuumed tuples, and press on, but be careful
1125 * not to reset latestRemovedXid since we want that value to be
1126 * valid.
1127 */
1130 /*
1131 * Vacuum the Free Space Map to make newly-freed space visible on
1132 * upper-level FSM pages. Note we have not yet processed blkno.
1133 */
1135 blkno);
1138 /* Report that we are once again scanning the heap */
1140 PROGRESS_VACUUM_PHASE_SCAN_HEAP);
1141 }
1143 /*
1144 * Pin the visibility map page in case we need to mark the page
1145 * all-visible. In most cases this will be very cheap, because we'll
1146 * already have the correct page pinned anyway. However, it's
1147 * possible that (a) next_unskippable_block is covered by a different
1148 * VM page than the current block or (b) we released our pin and did a
1149 * cycle of index vacuuming.
1150 */
1156 /* We need buffer cleanup lock so that we can prune HOT chains. */
1158 {
1159 /*
1160 * If we're not performing an aggressive scan to guard against XID
1161 * wraparound, and we don't want to forcibly check the page, then
1162 * it's OK to skip vacuuming pages we get a lock conflict on. They
1163 * will be dealt with in some future vacuum.
1164 */
1166 {
1170 }
1172 /*
1173 * Read the page with share lock to see if any xids on it need to
1174 * be frozen. If not we just skip the page, after updating our
1175 * scan statistics. If there are some, we wait for cleanup lock.
1176 *
1177 * We could defer the lock request further by remembering the page
1178 * and coming back to it later, or we could even register
1179 * ourselves for multiple buffers and then service whichever one
1180 * is received first. For now, this seems good enough.
1181 *
1182 * If we get here with aggressive false, then we're just forcibly
1183 * checking the page, and so we don't want to insist on getting
1184 * the lock; we only need to know if the page contains tuples, so
1185 * that we can update nonempty_pages correctly. It's convenient
1186 * to use lazy_check_needs_freeze() for both situations, though.
1187 */
1190 {
1197 }
1199 {
1200 /*
1201 * Here, we must not advance scanned_pages; that would amount
1202 * to claiming that the page contains no freezable tuples.
1203 */
1209 }
1212 /* drop through to normal processing */
1213 }
1221 {
1222 /*
1223 * All-zeroes pages can be left over if either a backend extends
1224 * the relation by a single page, but crashes before the newly
1225 * initialized page has been written out, or when bulk-extending
1226 * the relation (which creates a number of empty pages at the tail
1227 * end of the relation, but enters them into the FSM).
1228 *
1229 * Note we do not enter the page into the visibilitymap. That has
1230 * the downside that we repeatedly visit this page in subsequent
1231 * vacuums, but otherwise we'll never not discover the space on a
1232 * promoted standby. The harm of repeated checking ought to
1233 * normally not be too bad - the space usually should be used at
1234 * some point, otherwise there wouldn't be any regular vacuums.
1235 *
1236 * Make sure these pages are in the FSM, to ensure they can be
1237 * reused. Do that by testing if there's any space recorded for
1238 * the page. If not, enter it. We do so after releasing the lock
1239 * on the heap page, the FSM is approximate, after all.
1240 */
1243 empty_pages++;
1246 {
1247 Size freespace;
1251 }
1253 }
1256 {
1257 empty_pages++;
1260 /*
1261 * Empty pages are always all-visible and all-frozen (note that
1262 * the same is currently not true for new pages, see above).
1263 */
1265 {
1268 /* mark buffer dirty before writing a WAL record */
1271 /*
1272 * It's possible that another backend has extended the heap,
1273 * initialized the page, and then failed to WAL-log the page
1274 * due to an ERROR. Since heap extension is not WAL-logged,
1275 * recovery might try to replay our record setting the page
1276 * all-visible and find that the page isn't initialized, which
1277 * will cause a PANIC. To prevent that, check whether the
1278 * page has been previously WAL-logged, and if not, do that
1279 * now.
1280 */
1290 }
1295 }
1297 /*
1298 * Prune all HOT-update chains in this page.
1299 *
1300 * We count tuples removed by the pruning step as removed by VACUUM
1301 * (existing LP_DEAD line pointers don't count).
1302 */
1308 /*
1309 * Now scan the page to collect vacuumable items and check for tuples
1310 * requiring freezing.
1311 */
1319 /*
1320 * Note: If you change anything in the loop below, also look at
1321 * heap_page_is_all_visible to see if that needs to be changed.
1322 */
1326 {
1327 ItemId itemid;
1329 /*
1330 * Set the offset number so that we can display it along with any
1331 * error that occurred while processing this tuple.
1332 */
1336 /* Unused items require no processing, but we count 'em */
1338 {
1341 }
1343 /* Redirect items mustn't be touched */
1345 {
1348 }
1352 /*
1353 * LP_DEAD line pointers are to be vacuumed normally; but we don't
1354 * count them in tups_vacuumed, else we'd be double-counting (at
1355 * least in the common case where heap_page_prune() just freed up
1356 * a non-HOT tuple). Note also that the final tups_vacuumed value
1357 * might be very low for tables where opportunistic page pruning
1358 * happens to occur very frequently (via heap_page_prune_opt()
1359 * calls that free up non-HOT tuples).
1360 */
1362 {
1367 }
1377 /*
1378 * The criteria for counting a tuple as live in this block need to
1379 * match what analyze.c's acquire_sample_rows() does, otherwise
1380 * VACUUM and ANALYZE may produce wildly different reltuples
1381 * values, e.g. when there are many recently-dead tuples.
1382 *
1383 * The logic here is a bit simpler than acquire_sample_rows(), as
1384 * VACUUM can't run inside a transaction block, which makes some
1385 * cases impossible (e.g. in-progress insert from the same
1386 * transaction).
1387 */
1389 {
1392 /*
1393 * Ordinarily, DEAD tuples would have been removed by
1394 * heap_page_prune(), but it's possible that the tuple
1395 * state changed since heap_page_prune() looked. In
1396 * particular an INSERT_IN_PROGRESS tuple could have
1397 * changed to DEAD if the inserter aborted. So this
1398 * cannot be considered an error condition.
1399 *
1400 * If the tuple is HOT-updated then it must only be
1401 * removed by a prune operation; so we keep it just as if
1402 * it were RECENTLY_DEAD. Also, if it's a heap-only
1403 * tuple, we choose to keep it, because it'll be a lot
1404 * cheaper to get rid of it in the next pruning pass than
1405 * to treat it like an indexed tuple. Finally, if index
1406 * cleanup is disabled, the second heap pass will not
1407 * execute, and the tuple will not get removed, so we must
1408 * treat it like any other dead tuple that we choose to
1409 * keep.
1410 *
1411 * If this were to happen for a tuple that actually needed
1412 * to be deleted, we'd be in trouble, because it'd
1413 * possibly leave a tuple below the relation's xmin
1414 * horizon alive. heap_prepare_freeze_tuple() is prepared
1415 * to detect that case and abort the transaction,
1416 * preventing corruption.
1417 */
1422 else
1428 /*
1429 * Count it as live. Not only is this natural, but it's
1430 * also what acquire_sample_rows() does.
1431 */
1434 /*
1435 * Is the tuple definitely visible to all transactions?
1436 *
1437 * NB: Like with per-tuple hint bits, we can't set the
1438 * PD_ALL_VISIBLE flag if the inserter committed
1439 * asynchronously. See SetHintBits for more info. Check
1440 * that the tuple is hinted xmin-committed because of
1441 * that.
1442 */
1444 {
1445 TransactionId xmin;
1448 {
1451 }
1453 /*
1454 * The inserter definitely committed. But is it old
1455 * enough that everyone sees it as committed?
1456 */
1459 {
1462 }
1464 /* Track newest xmin on page. */
1467 }
1471 /*
1472 * If tuple is recently deleted then we must not remove it
1473 * from relation.
1474 */
1480 /*
1481 * This is an expected case during concurrent vacuum.
1482 *
1483 * We do not count these rows as live, because we expect
1484 * the inserting transaction to update the counters at
1485 * commit, and we assume that will happen only after we
1486 * report our results. This assumption is a bit shaky,
1487 * but it is what acquire_sample_rows() does, so be
1488 * consistent.
1489 */
1493 /* This is an expected case during concurrent vacuum */
1496 /*
1497 * Count such rows as live. As above, we assume the
1498 * deleting transaction will commit and update the
1499 * counters after we report.
1500 */
1506 }
1509 {
1515 }
1516 else
1517 {
1523 /*
1524 * Each non-removable tuple must be checked to see if it needs
1525 * freezing. Note we already have exclusive buffer lock.
1526 */
1538 }
1541 /*
1542 * Clear the offset information once we have processed all the tuples
1543 * on the page.
1544 */
1547 /*
1548 * If we froze any tuples, mark the buffer dirty, and write a WAL
1549 * record recording the changes. We must log the changes to be
1550 * crash-safe against future truncation of CLOG.
1551 */
1553 {
1558 /* execute collected freezes */
1560 {
1561 ItemId itemid;
1562 HeapTupleHeader htup;
1568 }
1570 /* Now WAL-log freezing if necessary */
1572 {
1573 XLogRecPtr recptr;
1578 }
1581 }
1583 /*
1584 * If there are no indexes we can vacuum the page right now instead of
1585 * doing a second scan. Also we don't do that but forget dead tuples
1586 * when index cleanup is disabled.
1587 */
1589 {
1591 {
1592 /* Remove tuples from heap if the table has no index */
1594 vacuumed_pages++;
1596 }
1597 else
1598 {
1599 /*
1600 * Here, we have indexes but index cleanup is disabled.
1601 * Instead of vacuuming the dead tuples on the heap, we just
1602 * forget them.
1603 *
1604 * Note that vacrelstats->dead_tuples could have tuples which
1605 * became dead after HOT-pruning but are not marked dead yet.
1606 * We do not process them because it's a very rare condition,
1607 * and the next vacuum will process them anyway.
1608 */
1610 }
1612 /*
1613 * Forget the now-vacuumed tuples, and press on, but be careful
1614 * not to reset latestRemovedXid since we want that value to be
1615 * valid.
1616 */
1619 /*
1620 * Periodically do incremental FSM vacuuming to make newly-freed
1621 * space visible on upper FSM pages. Note: although we've cleaned
1622 * the current block, we haven't yet updated its FSM entry (that
1623 * happens further down), so passing end == blkno is correct.
1624 */
1626 {
1628 blkno);
1630 }
1631 }
1635 /* mark page all-visible, if appropriate */
1637 {
1643 /*
1644 * It should never be the case that the visibility map page is set
1645 * while the page-level bit is clear, but the reverse is allowed
1646 * (if checksums are not enabled). Regardless, set both bits so
1647 * that we get back in sync.
1648 *
1649 * NB: If the heap page is all-visible but the VM bit is not set,
1650 * we don't need to dirty the heap page. However, if checksums
1651 * are enabled, we do need to make sure that the heap page is
1652 * dirtied before passing it to visibilitymap_set(), because it
1653 * may be logged. Given that this situation should only happen in
1654 * rare cases after a crash, it is not worth optimizing.
1655 */
1660 }
1662 /*
1663 * As of PostgreSQL 9.2, the visibility map bit should never be set if
1664 * the page-level bit is clear. However, it's possible that the bit
1665 * got cleared after we checked it and before we took the buffer
1666 * content lock, so we must recheck before jumping to the conclusion
1667 * that something bad has happened.
1668 */
1671 {
1672 elog(WARNING, "page is not marked all-visible but visibility map bit is set in relation \"%s\" page %u",
1675 VISIBILITYMAP_VALID_BITS);
1676 }
1678 /*
1679 * It's possible for the value returned by
1680 * GetOldestNonRemovableTransactionId() to move backwards, so it's not
1681 * wrong for us to see tuples that appear to not be visible to
1682 * everyone yet, while PD_ALL_VISIBLE is already set. The real safe
1683 * xmin value never moves backwards, but
1684 * GetOldestNonRemovableTransactionId() is conservative and sometimes
1685 * returns a value that's unnecessarily small, so if we see that
1686 * contradiction it just means that the tuples that we think are not
1687 * visible to everyone yet actually are, and the PD_ALL_VISIBLE flag
1688 * is correct.
1689 *
1690 * There should never be dead tuples on a page with PD_ALL_VISIBLE
1691 * set, however.
1692 */
1694 {
1695 elog(WARNING, "page containing dead tuples is marked as all-visible in relation \"%s\" page %u",
1700 VISIBILITYMAP_VALID_BITS);
1701 }
1703 /*
1704 * If the all-visible page is all-frozen but not marked as such yet,
1705 * mark it as all-frozen. Note that all_frozen is only valid if
1706 * all_visible is true, so we must check both.
1707 */
1710 {
1711 /*
1712 * We can pass InvalidTransactionId as the cutoff XID here,
1713 * because setting the all-frozen bit doesn't cause recovery
1714 * conflicts.
1715 */
1718 VISIBILITYMAP_ALL_FROZEN);
1719 }
1723 /* Remember the location of the last page with nonremovable tuples */
1727 /*
1728 * If we remembered any tuples for deletion, then the page will be
1729 * visited again by lazy_vacuum_heap_rel, which will compute and record
1730 * its post-compaction free space. If not, then we're done with this
1731 * page, so remember its free space as-is. (This path will always be
1732 * taken if there are no indexes.)
1733 */
1736 }
1738 /* report that everything is scanned and vacuumed */
1741 /* Clear the block number information */
1746 /* save stats for use later */
1750 /* now we can compute the new value for pg_class.reltuples */
1753 live_tuples);
1755 /*
1756 * Also compute the total number of surviving heap entries. In the
1757 * (unlikely) scenario that new_live_tuples is -1, take it as zero.
1758 */
1762 /*
1763 * Release any remaining pin on visibility map page.
1764 */
1766 {
1769 }
1771 /* If any tuples need to be deleted, perform final vacuum cycle */
1772 /* XXX put a threshold on min number of tuples here? */
1774 {
1775 /* Work on all the indexes, and then the heap */
1778 /* Remove tuples from heap */
1780 }
1782 /*
1783 * Vacuum the remainder of the Free Space Map. We must do this whether or
1784 * not there were indexes.
1785 */
1789 /* report all blocks vacuumed */
1792 /* Do post-vacuum cleanup */
1796 /*
1797 * Free resources managed by lazy_space_alloc(). (We must end parallel
1798 * mode/free shared memory before updating index statistics. We cannot
1799 * write while in parallel mode.)
1800 */
1803 /* Update index statistics */
1807 /* If no indexes, make log report that lazy_vacuum_heap_rel would've made */
1819 nunused);
1830 empty_pages),
1831 empty_pages);
1841 }
1843 /*
1844 * lazy_vacuum_all_indexes() -- Main entry for index vacuuming
1845 */
1846 static void
1848 {
1854 /* Log cleanup info before we touch indexes */
1857 /* Report that we are now vacuuming indexes */
1859 PROGRESS_VACUUM_PHASE_VACUUM_INDEX);
1862 {
1864 {
1870 vacrel);
1871 }
1872 }
1873 else
1874 {
1875 /* Outsource everything to parallel variant */
1877 }
1879 /* Increase and report the number of index scans */
1883 }
1885 /*
1886 * lazy_vacuum_heap_rel() -- second pass over the heap for two pass strategy
1887 *
1888 * This routine marks dead tuples as unused and compacts out free space on
1889 * their pages. Pages not having dead tuples recorded from lazy_scan_heap are
1890 * not visited at all.
1891 *
1892 * Note: the reason for doing this as a second pass is we cannot remove the
1893 * tuples until we've removed their index entries, and we want to process
1894 * index entry removal in batches as large as possible.
1895 */
1896 static void
1898 {
1901 PGRUsage ru0;
1903 LVSavedErrInfo saved_err_info;
1905 /* Report that we are now vacuuming the heap */
1907 PROGRESS_VACUUM_PHASE_VACUUM_HEAP);
1909 /* Update error traceback information */
1911 VACUUM_ERRCB_PHASE_VACUUM_HEAP,
1919 {
1920 BlockNumber tblk;
1921 Buffer buf;
1922 Page page;
1923 Size freespace;
1932 {
1936 }
1940 /* Now that we've compacted the page, record its available space */
1946 vacuumed_pages++;
1947 }
1949 /* Clear the block number information */
1953 {
1956 }
1963 /* Revert to the previous phase information for error traceback */
1965 }
1967 /*
1968 * lazy_vacuum_heap_page() -- free dead tuples on a page
1969 * and repair its fragmentation.
1970 *
1971 * Caller must hold pin and buffer cleanup lock on the buffer.
1972 *
1973 * tupindex is the index in vacrel->dead_tuples of the first dead tuple for
1974 * this page. We assume the rest follow sequentially. The return value is
1975 * the first tupindex after the tuples of this page.
1976 */
1977 static int
1980 {
1985 TransactionId visibility_cutoff_xid;
1987 LVSavedErrInfo saved_err_info;
1991 /* Update error traceback information */
1994 InvalidOffsetNumber);
1999 {
2000 BlockNumber tblk;
2001 OffsetNumber toff;
2002 ItemId itemid;
2011 }
2015 /*
2016 * Mark buffer dirty before we write WAL.
2017 */
2020 /* XLOG stuff */
2022 {
2023 XLogRecPtr recptr;
2030 }
2032 /*
2033 * End critical section, so we safely can do visibility tests (which
2034 * possibly need to perform IO and allocate memory!). If we crash now the
2035 * page (including the corresponding vm bit) might not be marked all
2036 * visible, but that's fine. A later vacuum will fix that.
2037 */
2040 /*
2041 * Now that we have removed the dead tuples from the page, once again
2042 * check if the page has become all-visible. The page is already marked
2043 * dirty, exclusively locked, and, if needed, a full page image has been
2044 * emitted in the log_heap_clean() above.
2045 */
2050 /*
2051 * All the changes to the heap page have been done. If the all-visible
2052 * flag is now set, also set the VM all-visible bit (and, if possible, the
2053 * all-frozen bit) unless this has already been done previously.
2054 */
2056 {
2061 /* Set the VM all-frozen bit to flag, if needed */
2071 }
2073 /* Revert to the previous phase information for error traceback */
2076 }
2078 /*
2079 * lazy_check_needs_freeze() -- scan page to see if any tuples
2080 * need to be cleaned to avoid wraparound
2081 *
2082 * Returns true if the page needs to be vacuumed using cleanup lock.
2083 * Also returns a flag indicating whether page contains any tuples at all.
2084 */
2085 static bool
2087 {
2089 OffsetNumber offnum,
2090 maxoff;
2091 HeapTupleHeader tupleheader;
2095 /*
2096 * New and empty pages, obviously, don't contain tuples. We could make
2097 * sure that the page is registered in the FSM, but it doesn't seem worth
2098 * waiting for a cleanup lock just for that, especially because it's
2099 * likely that the pin holder will do so.
2100 */
2108 {
2109 ItemId itemid;
2111 /*
2112 * Set the offset number so that we can display it along with any
2113 * error that occurred while processing this tuple.
2114 */
2118 /* this should match hastup test in count_nondeletable_pages() */
2122 /* dead and redirect items never need freezing */
2133 /* Clear the offset information once we have processed the given page. */
2137 }
2139 /*
2140 * Perform lazy_vacuum_all_indexes() steps in parallel
2141 */
2142 static void
2144 {
2145 /* Tell parallel workers to do index vacuuming */
2149 /*
2150 * We can only provide an approximate value of num_heap_tuples in vacuum
2151 * cases.
2152 */
2158 }
2160 /*
2161 * Perform lazy_cleanup_all_indexes() steps in parallel
2162 */
2163 static void
2165 {
2168 /*
2169 * If parallel vacuum is active we perform index cleanup with parallel
2170 * workers.
2171 *
2172 * Tell parallel workers to do index cleanup.
2173 */
2177 /*
2178 * Now we can provide a better estimate of total number of surviving
2179 * tuples (we assume indexes are more interested in that than in the
2180 * number of nominally live tuples).
2181 */
2186 /* Determine the number of parallel workers to launch */
2190 else
2194 }
2196 /*
2197 * Perform index vacuum or index cleanup with parallel workers. This function
2198 * must be used by the parallel vacuum leader process. The caller must set
2199 * lps->lvshared->for_cleanup to indicate whether to perform vacuum or
2200 * cleanup.
2201 */
2202 static void
2204 {
2211 /* The leader process will participate */
2212 nworkers--;
2214 /*
2215 * It is possible that parallel context is initialized with fewer workers
2216 * than the number of indexes that need a separate worker in the current
2217 * phase, so we need to consider it. See compute_parallel_vacuum_workers.
2218 */
2221 /* Setup the shared cost-based vacuum delay and launch workers */
2223 {
2225 {
2226 /* Reset the parallel index processing counter */
2229 /* Reinitialize the parallel context to relaunch parallel workers */
2231 }
2233 /*
2234 * Set up shared cost balance and the number of active workers for
2235 * vacuum delay. We need to do this before launching workers as
2236 * otherwise, they might not see the updated values for these
2237 * parameters.
2238 */
2242 /*
2243 * The number of workers can vary between bulkdelete and cleanup
2244 * phase.
2245 */
2251 {
2252 /*
2253 * Reset the local cost values for leader backend as we have
2254 * already accumulated the remaining balance of heap.
2255 */
2259 /* Enable shared cost balance for leader backend */
2262 }
2270 else
2276 }
2278 /* Process the indexes that can be processed by only leader process */
2281 /*
2282 * Join as a parallel worker. The leader process alone processes all the
2283 * indexes in the case where no workers are launched.
2284 */
2287 /*
2288 * Next, accumulate buffer and WAL usage. (This must wait for the workers
2289 * to finish, or we might get incomplete data.)
2290 */
2292 {
2293 /* Wait for all vacuum workers to finish */
2298 }
2300 /*
2301 * Carry the shared balance value to heap scan and disable shared costing
2302 */
2304 {
2308 }
2309 }
2311 /*
2312 * Index vacuum/cleanup routine used by the leader process and parallel
2313 * vacuum worker processes to process the indexes in parallel.
2314 */
2315 static void
2317 {
2318 /*
2319 * Increment the active worker count if we are able to launch any worker.
2320 */
2324 /* Loop until all indexes are vacuumed */
2326 {
2329 Relation indrel;
2332 /* Get an index number to process */
2335 /* Done for all indexes? */
2339 /* Get the index statistics of this index from DSM */
2342 /* Skip indexes not participating in parallelism */
2348 /*
2349 * Skip processing indexes that are unsafe for workers (these are
2350 * processed in do_serial_processing_for_unsafe_indexes() by leader)
2351 */
2355 /* Do vacuum or cleanup of the index */
2358 lvshared,
2359 shared_istat,
2360 vacrel);
2361 }
2363 /*
2364 * We have completed the index vacuum so decrement the active worker
2365 * count.
2366 */
2369 }
2371 /*
2372 * Vacuum or cleanup indexes that can be processed by only the leader process
2373 * because these indexes don't support parallel operation at that phase.
2374 */
2375 static void
2377 {
2380 /*
2381 * Increment the active worker count if we are able to launch any worker.
2382 */
2387 {
2389 Relation indrel;
2394 /* Skip already-complete indexes */
2400 /*
2401 * We're only here for the unsafe indexes
2402 */
2406 /* Do vacuum or cleanup of the index */
2409 lvshared,
2410 shared_istat,
2411 vacrel);
2412 }
2414 /*
2415 * We have completed the index vacuum so decrement the active worker
2416 * count.
2417 */
2420 }
2422 /*
2423 * Vacuum or cleanup index either by leader process or by one of the worker
2424 * process. After processing the index this function copies the index
2425 * statistics returned from ambulkdelete and amvacuumcleanup to the DSM
2426 * segment.
2427 */
2434 {
2437 /*
2438 * Update the pointer to the corresponding bulk-deletion result if someone
2439 * has already updated it
2440 */
2444 /* Do vacuum or cleanup of the index */
2448 else
2450 vacrel);
2452 /*
2453 * Copy the index bulk-deletion result returned from ambulkdelete and
2454 * amvacuumcleanup to the DSM segment if it's the first cycle because they
2455 * allocate locally and it's possible that an index will be vacuumed by a
2456 * different vacuum process the next cycle. Copying the result normally
2457 * happens only the first time an index is vacuumed. For any additional
2458 * vacuum pass, we directly point to the result on the DSM segment and
2459 * pass it to vacuum index APIs so that workers can update it directly.
2460 *
2461 * Since all vacuum workers write the bulk-deletion result at different
2462 * slots we can write them without locking.
2463 */
2465 {
2469 /* Free the locally-allocated bulk-deletion result */
2472 /* return the pointer to the result from shared memory */
2474 }
2477 }
2479 /*
2480 * lazy_cleanup_all_indexes() -- cleanup all indexes of relation.
2481 */
2482 static void
2484 {
2488 /* Report that we are now cleaning up indexes */
2490 PROGRESS_VACUUM_PHASE_INDEX_CLEANUP);
2493 {
2499 {
2506 }
2507 }
2508 else
2509 {
2510 /* Outsource everything to parallel variant */
2512 }
2513 }
2515 /*
2516 * lazy_vacuum_one_index() -- vacuum index relation.
2517 *
2518 * Delete all the index entries pointing to tuples listed in
2519 * dead_tuples, and update running statistics.
2520 *
2521 * reltuples is the number of heap tuples to be passed to the
2522 * bulkdelete callback. It's always assumed to be estimated.
2523 *
2524 * Returns bulk delete stats derived from input stats
2525 */
2529 {
2530 IndexVacuumInfo ivinfo;
2531 PGRUsage ru0;
2532 LVSavedErrInfo saved_err_info;
2544 /*
2545 * Update error traceback information.
2546 *
2547 * The index name is saved during this phase and restored immediately
2548 * after this phase. See vacuum_error_callback.
2549 */
2553 VACUUM_ERRCB_PHASE_VACUUM_INDEX,
2556 /* Do bulk deletion */
2565 /* Revert to the previous phase information for error traceback */
2571 }
2573 /*
2574 * lazy_cleanup_one_index() -- do post-vacuum cleanup for index relation.
2575 *
2576 * reltuples is the number of heap tuples and estimated_count is true
2577 * if reltuples is an estimated value.
2578 *
2579 * Returns bulk delete stats derived from input stats
2580 */
2585 {
2586 IndexVacuumInfo ivinfo;
2587 PGRUsage ru0;
2588 LVSavedErrInfo saved_err_info;
2601 /*
2602 * Update error traceback information.
2603 *
2604 * The index name is saved during this phase and restored immediately
2605 * after this phase. See vacuum_error_callback.
2606 */
2610 VACUUM_ERRCB_PHASE_INDEX_CLEANUP,
2616 {
2630 }
2632 /* Revert to the previous phase information for error traceback */
2638 }
2640 /*
2641 * should_attempt_truncation - should we attempt to truncate the heap?
2642 *
2643 * Don't even think about it unless we have a shot at releasing a goodly
2644 * number of pages. Otherwise, the time taken isn't worth it.
2645 *
2646 * Also don't attempt it if we are doing early pruning/vacuuming, because a
2647 * scan which cannot find a truncated heap page cannot determine that the
2648 * snapshot is too old to read that page. We might be able to get away with
2649 * truncating all except one of the pages, setting its LSN to (at least) the
2650 * maximum of the truncated range if we also treated an index leaf tuple
2651 * pointing to a missing heap page as something to trigger the "snapshot too
2652 * old" error, but that seems fragile and seems like it deserves its own patch
2653 * if we consider it.
2654 *
2655 * This is split out so that we can test whether truncation is going to be
2656 * called for before we actually do it. If you change the logic here, be
2657 * careful to depend only on fields that lazy_scan_heap updates on-the-fly.
2658 */
2659 static bool
2661 {
2662 BlockNumber possibly_freeable;
2673 else
2675 }
2677 /*
2678 * lazy_truncate_heap - try to truncate off any empty pages at the end
2679 */
2680 static void
2682 {
2684 BlockNumber new_rel_pages;
2687 /* Report that we are now truncating */
2689 PROGRESS_VACUUM_PHASE_TRUNCATE);
2691 /*
2692 * Loop until no more truncating can be done.
2693 */
2694 do
2695 {
2696 PGRUsage ru0;
2700 /*
2701 * We need full exclusive lock on the relation in order to do
2702 * truncation. If we can't get it, give up rather than waiting --- we
2703 * don't want to block other backends, and we don't want to deadlock
2704 * (which is quite possible considering we already hold a lower-grade
2705 * lock).
2706 */
2710 {
2714 /*
2715 * Check for interrupts while trying to (re-)acquire the exclusive
2716 * lock.
2717 */
2721 VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL))
2722 {
2723 /*
2724 * We failed to establish the lock in the specified number of
2725 * retries. This means we give up truncating.
2726 */
2732 }
2735 }
2737 /*
2738 * Now that we have exclusive lock, look to see if the rel has grown
2739 * whilst we were vacuuming with non-exclusive lock. If so, give up;
2740 * the newly added pages presumably contain non-deletable tuples.
2741 */
2744 {
2745 /*
2746 * Note: we intentionally don't update vacrel->rel_pages with the
2747 * new rel size here. If we did, it would amount to assuming that
2748 * the new pages are empty, which is unlikely. Leaving the numbers
2749 * alone amounts to assuming that the new pages have the same
2750 * tuple density as existing ones, which is less unlikely.
2751 */
2754 }
2756 /*
2757 * Scan backwards from the end to verify that the end pages actually
2758 * contain no tuples. This is *necessary*, not optional, because
2759 * other backends could have added tuples to these pages whilst we
2760 * were vacuuming.
2761 */
2766 {
2767 /* can't do anything after all */
2770 }
2772 /*
2773 * Okay to truncate.
2774 */
2777 /*
2778 * We can release the exclusive lock as soon as we have truncated.
2779 * Other backends can't safely access the relation until they have
2780 * processed the smgr invalidation that smgrtruncate sent out ... but
2781 * that should happen as part of standard invalidation processing once
2782 * they acquire lock on the relation.
2783 */
2786 /*
2787 * Update statistics. Here, it *is* correct to adjust rel_pages
2788 * without also touching reltuples, since the tuple count wasn't
2789 * changed by the truncation.
2790 */
2803 }
2805 /*
2806 * Rescan end pages to verify that they are (still) empty of tuples.
2807 *
2808 * Returns number of nondeletable pages (last nonempty page + 1).
2809 */
2810 static BlockNumber
2812 {
2813 BlockNumber blkno;
2814 BlockNumber prefetchedUntil;
2815 instr_time starttime;
2817 /* Initialize the starttime if we check for conflicting lock requests */
2820 /*
2821 * Start checking blocks at what we believe relation end to be and move
2822 * backwards. (Strange coding of loop control is needed because blkno is
2823 * unsigned.) To make the scan faster, we prefetch a few blocks at a time
2824 * in forward direction, so that OS-level readahead can kick in.
2825 */
2831 {
2832 Buffer buf;
2833 Page page;
2834 OffsetNumber offnum,
2835 maxoff;
2838 /*
2839 * Check if another process requests a lock on our relation. We are
2840 * holding an AccessExclusiveLock here, so they will be waiting. We
2841 * only do this once per VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL, and we
2842 * only check if that interval has elapsed once every 32 blocks to
2843 * keep the number of system calls and actual shared lock table
2844 * lookups to a minimum.
2845 */
2847 {
2848 instr_time currenttime;
2849 instr_time elapsed;
2856 {
2858 {
2865 }
2867 }
2868 }
2870 /*
2871 * We don't insert a vacuum delay point here, because we have an
2872 * exclusive lock on the table which we want to hold for as short a
2873 * time as possible. We still need to check for interrupts however.
2874 */
2877 blkno--;
2879 /* If we haven't prefetched this lot yet, do so now. */
2881 {
2882 BlockNumber prefetchStart;
2883 BlockNumber pblkno;
2887 {
2890 }
2892 }
2897 /* In this phase we only need shared access to the buffer */
2903 {
2906 }
2913 {
2914 ItemId itemid;
2918 /*
2919 * Note: any non-unused item should be taken as a reason to keep
2920 * this page. We formerly thought that DEAD tuples could be
2921 * thrown away, but that's not so, because we'd not have cleaned
2922 * out their index entries.
2923 */
2925 {
2928 }
2933 /* Done scanning if we found a tuple here */
2936 }
2938 /*
2939 * If we fall out of the loop, all the previously-thought-to-be-empty
2940 * pages still are; we need not bother to look at the last known-nonempty
2941 * page.
2942 */
2944 }
2946 /*
2947 * Return the maximum number of dead tuples we can record.
2948 */
2949 static long
2951 {
2958 {
2963 /* curious coding here to ensure the multiplication can't overflow */
2967 /* stay sane if small maintenance_work_mem */
2969 }
2970 else
2974 }
2976 /*
2977 * lazy_space_alloc - space allocation decisions for lazy vacuum
2978 *
2979 * See the comments at the head of this file for rationale.
2980 */
2981 static void
2983 {
2987 /*
2988 * Initialize state for a parallel vacuum. As of now, only one worker can
2989 * be used for an index, so we invoke parallelism only if there are at
2990 * least two indexes on a table.
2991 */
2993 {
2994 /*
2995 * Since parallel workers cannot access data in temporary tables, we
2996 * can't perform parallel vacuum on them.
2997 */
2999 {
3000 /*
3001 * Give warning only if the user explicitly tries to perform a
3002 * parallel vacuum on the temporary table.
3003 */
3006 (errmsg("disabling parallel option of vacuum on \"%s\" --- cannot vacuum temporary tables in parallel",
3008 }
3009 else
3012 /* If parallel mode started, we're done */
3015 }
3024 }
3026 /*
3027 * lazy_space_free - free space allocated in lazy_space_alloc
3028 */
3029 static void
3031 {
3035 /*
3036 * End parallel mode before updating index statistics as we cannot write
3037 * during parallel mode.
3038 */
3040 }
3042 /*
3043 * lazy_record_dead_tuple - remember one deletable tuple
3044 */
3045 static void
3047 {
3048 /*
3049 * The array shouldn't overflow under normal behavior, but perhaps it
3050 * could if we are given a really small maintenance_work_mem. In that
3051 * case, just forget the last few tuples (we'll get 'em next time).
3052 */
3054 {
3059 }
3060 }
3062 /*
3063 * lazy_tid_reaped() -- is a particular tid deletable?
3064 *
3065 * This has the right signature to be an IndexBulkDeleteCallback.
3066 *
3067 * Assumes dead_tuples array is in sorted order.
3068 */
3069 static bool
3071 {
3073 int64 litem,
3074 ritem,
3075 item;
3076 ItemPointer res;
3082 /*
3083 * Doing a simple bound check before bsearch() is useful to avoid the
3084 * extra cost of bsearch(), especially if dead tuples on the heap are
3085 * concentrated in a certain range. Since this function is called for
3086 * every index tuple, it pays to be really fast.
3087 */
3095 vac_cmp_itemptr);
3098 }
3100 /*
3101 * Comparator routines for use with qsort() and bsearch().
3102 */
3103 static int
3105 {
3106 BlockNumber lblk,
3107 rblk;
3108 OffsetNumber loff,
3109 roff;
3128 }
3130 /*
3131 * Check if every tuple in the given page is visible to all current and future
3132 * transactions. Also return the visibility_cutoff_xid which is the highest
3133 * xmin amongst the visible tuples. Set *all_frozen to true if every tuple
3134 * on this page is frozen.
3135 */
3136 static bool
3140 {
3143 OffsetNumber offnum,
3144 maxoff;
3150 /*
3151 * This is a stripped down version of the line pointer scan in
3152 * lazy_scan_heap(). So if you change anything here, also check that code.
3153 */
3158 {
3159 ItemId itemid;
3160 HeapTupleData tuple;
3162 /*
3163 * Set the offset number so that we can display it along with any
3164 * error that occurred while processing this tuple.
3165 */
3169 /* Unused or redirect line pointers are of no interest */
3175 /*
3176 * Dead line pointers can have index pointers pointing to them. So
3177 * they can't be treated as visible
3178 */
3180 {
3184 }
3193 {
3195 {
3196 TransactionId xmin;
3198 /* Check comments in lazy_scan_heap. */
3200 {
3204 }
3206 /*
3207 * The inserter definitely committed. But is it old enough
3208 * that everyone sees it as committed?
3209 */
3212 {
3216 }
3218 /* Track newest xmin on page. */
3222 /* Check whether this tuple is already frozen or not */
3226 }
3233 {
3237 }
3241 }
3244 /* Clear the offset information once we have processed the given page. */
3248 }
3250 /*
3251 * Compute the number of parallel worker processes to request. Both index
3252 * vacuum and index cleanup can be executed with parallel workers. The index
3253 * is eligible for parallel vacuum iff its size is greater than
3254 * min_parallel_index_scan_size as invoking workers for very small indexes
3255 * can hurt performance.
3256 *
3257 * nrequested is the number of parallel workers that user requested. If
3258 * nrequested is 0, we compute the parallel degree based on nindexes, that is
3259 * the number of indexes that support parallel vacuum. This function also
3260 * sets can_parallel_vacuum to remember indexes that participate in parallel
3261 * vacuum.
3262 */
3263 static int
3266 {
3272 /*
3273 * We don't allow performing parallel operation in standalone backend or
3274 * when parallelism is disabled.
3275 */
3279 /*
3280 * Compute the number of indexes that can participate in parallel vacuum.
3281 */
3283 {
3294 nindexes_parallel_bulkdel++;
3297 nindexes_parallel_cleanup++;
3298 }
3301 nindexes_parallel_cleanup);
3303 /* The leader process takes one index */
3304 nindexes_parallel--;
3306 /* No index supports parallel vacuum */
3310 /* Compute the parallel degree */
3314 /* Cap by max_parallel_maintenance_workers */
3318 }
3320 /*
3321 * Update index statistics in pg_class if the statistics are accurate.
3322 */
3323 static void
3325 {
3333 {
3340 /* Update index statistics */
3346 InvalidTransactionId,
3347 InvalidMultiXactId,
3349 }
3350 }
3352 /*
3353 * This function prepares and returns parallel vacuum state if we can launch
3354 * even one worker. This function is responsible for entering parallel mode,
3355 * create a parallel context, and then initialize the DSM segment.
3356 */
3360 {
3371 Size est_shared;
3372 Size est_deadtuples;
3377 /*
3378 * A parallel vacuum must be requested and there must be indexes on the
3379 * relation
3380 */
3384 /*
3385 * Compute the number of parallel vacuum workers to launch
3386 */
3389 nrequested,
3390 can_parallel_vacuum);
3392 /* Can't perform vacuum in parallel */
3394 {
3397 }
3403 parallel_workers);
3407 /* Estimate size for shared information -- PARALLEL_VACUUM_KEY_SHARED */
3410 {
3414 /*
3415 * Cleanup option should be either disabled, always performing in
3416 * parallel or conditionally performing in parallel.
3417 */
3422 /* Skip indexes that don't participate in parallel vacuum */
3427 nindexes_mwm++;
3431 /*
3432 * Remember the number of indexes that support parallel operation for
3433 * each phase.
3434 */
3441 }
3445 /* Estimate size for dead tuples -- PARALLEL_VACUUM_KEY_DEAD_TUPLES */
3451 /*
3452 * Estimate space for BufferUsage and WalUsage --
3453 * PARALLEL_VACUUM_KEY_BUFFER_USAGE and PARALLEL_VACUUM_KEY_WAL_USAGE.
3454 *
3455 * If there are no extensions loaded that care, we could skip this. We
3456 * have no way of knowing whether anyone's looking at pgBufferUsage or
3457 * pgWalUsage, so do it unconditionally.
3458 */
3466 /* Finally, estimate PARALLEL_VACUUM_KEY_QUERY_TEXT space */
3468 {
3472 }
3473 else
3478 /* Prepare shared information */
3486 maintenance_work_mem;
3493 /*
3494 * Initialize variables for shared index statistics, set NULL bitmap and
3495 * the size of stats for each index.
3496 */
3499 {
3503 /* Set NOT NULL as this index does support parallelism */
3505 }
3510 /* Prepare the dead tuple space */
3518 /*
3519 * Allocate space for each worker's BufferUsage and WalUsage; no need to
3520 * initialize
3521 */
3531 /* Store query string for workers */
3533 {
3541 }
3545 }
3547 /*
3548 * Destroy the parallel context, and end parallel mode.
3549 *
3550 * Since writes are not allowed during parallel mode, copy the
3551 * updated index statistics from DSM into local memory and then later use that
3552 * to update the index statistics. One might think that we can exit from
3553 * parallel mode, update the index statistics and then destroy parallel
3554 * context, but that won't be safe (see ExitParallelMode).
3555 */
3556 static void
3558 {
3565 /* Copy the updated statistics */
3567 {
3572 /*
3573 * Skip unused slot. The statistics of this index are already stored
3574 * in local memory.
3575 */
3580 {
3583 }
3584 else
3586 }
3591 /* Deactivate parallel vacuum */
3594 }
3596 /*
3597 * Return shared memory statistics for index at offset 'getidx', if any
3598 */
3601 {
3609 {
3614 }
3617 }
3619 /*
3620 * Returns false, if the given index can't participate in parallel index
3621 * vacuum or parallel index cleanup
3622 */
3623 static bool
3625 {
3628 /* first_time must be true only if for_cleanup is true */
3632 {
3633 /* Skip, if the index does not support parallel cleanup */
3638 /*
3639 * Skip, if the index supports parallel cleanup conditionally, but we
3640 * have already processed the index (for bulkdelete). See the
3641 * comments for option VACUUM_OPTION_PARALLEL_COND_CLEANUP to know
3642 * when indexes support parallel cleanup conditionally.
3643 */
3647 }
3649 {
3650 /* Skip if the index does not support parallel bulk deletion */
3652 }
3655 }
3657 /*
3658 * Perform work within a launched parallel process.
3659 *
3660 * Since parallel vacuum workers perform only index vacuum or index cleanup,
3661 * we don't need to report progress information.
3662 */
3663 void
3665 {
3666 Relation rel;
3674 LVRelState vacrel;
3675 ErrorContextCallback errcallback;
3683 else
3686 /* Set debug_query_string for individual workers */
3691 /*
3692 * Open table. The lock mode is the same as the leader process. It's
3693 * okay because the lock mode does not conflict among the parallel
3694 * workers.
3695 */
3698 /*
3699 * Open all indexes. indrels are sorted in order by OID, which should be
3700 * matched to the leader's one.
3701 */
3705 /* Set dead tuple space */
3707 PARALLEL_VACUUM_KEY_DEAD_TUPLES,
3710 /* Set cost-based vacuum delay */
3729 /*
3730 * Initialize vacrel for use as error callback arg by parallel worker.
3731 */
3738 /* Setup error traceback support for ereport() */
3744 /* Prepare to track buffer usage during parallel execution */
3747 /* Process indexes to perform vacuum/cleanup */
3750 /* Report buffer/WAL usage during parallel execution */
3756 /* Pop the error context stack */
3762 }
3764 /*
3765 * Error context callback for errors occurring during vacuum.
3766 */
3767 static void
3769 {
3773 {
3776 {
3780 else
3783 }
3784 else
3791 {
3795 else
3798 }
3799 else
3823 * initialized */
3824 }
3825 }
3827 /*
3828 * Updates the information required for vacuum error callback. This also saves
3829 * the current information which can be later restored via restore_vacuum_error_info.
3830 */
3831 static void
3834 {
3836 {
3840 }
3845 }
3847 /*
3848 * Restores the vacuum information saved via a prior call to update_vacuum_error_info.
3849 */
3850 static void
3853 {
3857 }