Loading...
Searching...
No Matches
vacuumlazy.c File Reference
#include "postgres.h"#include "access/genam.h"#include "access/heapam.h"#include "access/htup_details.h"#include "access/multixact.h"#include "access/tidstore.h"#include "access/transam.h"#include "access/visibilitymap.h"#include "access/xloginsert.h"#include "catalog/storage.h"#include "commands/progress.h"#include "commands/vacuum.h"#include "common/int.h"#include "common/pg_prng.h"#include "executor/instrument.h"#include "miscadmin.h"#include "pgstat.h"#include "portability/instr_time.h"#include "postmaster/autovacuum.h"#include "storage/bufmgr.h"#include "storage/freespace.h"#include "storage/lmgr.h"#include "storage/read_stream.h"#include "utils/lsyscache.h"#include "utils/pg_rusage.h"#include "utils/timestamp.h"
Include dependency graph for vacuumlazy.c:
Go to the source code of this file.
Data Structures | |
| struct | LVRelState |
| struct | LVSavedErrInfo |
Macros | |
| #define | REL_TRUNCATE_MINIMUM 1000 |
| #define | REL_TRUNCATE_FRACTION 16 |
| #define | VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL 20 /* ms */ |
| #define | VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL 50 /* ms */ |
| #define | VACUUM_TRUNCATE_LOCK_TIMEOUT 5000 /* ms */ |
| #define | BYPASS_THRESHOLD_PAGES 0.02 /* i.e. 2% of rel_pages */ |
| #define | FAILSAFE_EVERY_PAGES ((BlockNumber) (((uint64) 4 * 1024 * 1024 * 1024) / BLCKSZ)) |
| #define | VACUUM_FSM_EVERY_PAGES ((BlockNumber) (((uint64) 8 * 1024 * 1024 * 1024) / BLCKSZ)) |
| #define | SKIP_PAGES_THRESHOLD ((BlockNumber) 32) |
| #define | PREFETCH_SIZE ((BlockNumber) 32) |
| #define | ParallelVacuumIsActive(vacrel) ((vacrel)->pvs != NULL) |
| #define | MAX_EAGER_FREEZE_SUCCESS_RATE 0.2 |
| #define | EAGER_SCAN_REGION_SIZE 4096 |
Typedefs | |
| typedef struct LVRelState | LVRelState |
| typedef struct LVSavedErrInfo | LVSavedErrInfo |
Macro Definition Documentation
◆ BYPASS_THRESHOLD_PAGES
Definition at line 184 of file vacuumlazy.c.
◆ EAGER_SCAN_REGION_SIZE
| #define EAGER_SCAN_REGION_SIZE 4096 |
Definition at line 247 of file vacuumlazy.c.
◆ FAILSAFE_EVERY_PAGES
| #define FAILSAFE_EVERY_PAGES ((BlockNumber) (((uint64) 4 * 1024 * 1024 * 1024) / BLCKSZ)) |
Definition at line 190 of file vacuumlazy.c.
221{
228} VacErrPhase;
229
230/*
231 * An eager scan of a page that is set all-frozen in the VM is considered
232 * "successful". To spread out freezing overhead across multiple normal
233 * vacuums, we limit the number of successful eager page freezes. The maximum
234 * number of eager page freezes is calculated as a ratio of the all-visible
235 * but not all-frozen pages at the beginning of the vacuum.
236 */
237#define MAX_EAGER_FREEZE_SUCCESS_RATE 0.2
238
239/*
240 * On the assumption that different regions of the table tend to have
241 * similarly aged data, once vacuum fails to freeze
242 * vacuum_max_eager_freeze_failure_rate of the blocks in a region of size
243 * EAGER_SCAN_REGION_SIZE, it suspends eager scanning until it has progressed
244 * to another region of the table with potentially older data.
245 */
246#define EAGER_SCAN_REGION_SIZE 4096
247
249{
250 /* Target heap relation and its indexes */
254
255 /* Buffer access strategy and parallel vacuum state */
258
259 /* Aggressive VACUUM? (must set relfrozenxid >= FreezeLimit) */
261 /* Use visibility map to skip? (disabled by DISABLE_PAGE_SKIPPING) */
263 /* Consider index vacuuming bypass optimization? */
265
266 /* Doing index vacuuming, index cleanup, rel truncation? */
270
271 /* VACUUM operation's cutoffs for freezing and pruning */
274 /* Tracks oldest extant XID/MXID for setting relfrozenxid/relminmxid */
278
279 /* Error reporting state */
288
289 /*
290 * dead_items stores TIDs whose index tuples are deleted by index
291 * vacuuming. Each TID points to an LP_DEAD line pointer from a heap page
292 * that has been processed by lazy_scan_prune. Also needed by
293 * lazy_vacuum_heap_rel, which marks the same LP_DEAD line pointers as
294 * LP_UNUSED during second heap pass.
295 *
296 * Both dead_items and dead_items_info are allocated in shared memory in
297 * parallel vacuum cases.
298 */
301
304
305 /*
306 * Count of all-visible blocks eagerly scanned (for logging only). This
307 * does not include skippable blocks scanned due to SKIP_PAGES_THRESHOLD.
308 */
310
313
314 /* # pages newly set all-visible in the VM */
316
317 /*
318 * # pages newly set all-visible and all-frozen in the VM. This is a
319 * subset of vm_new_visible_pages. That is, vm_new_visible_pages includes
320 * all pages set all-visible, but vm_new_visible_frozen_pages includes
321 * only those which were also set all-frozen.
322 */
324
325 /* # all-visible pages newly set all-frozen in the VM */
327
331
332 /* Statistics output by us, for table */
335 /* Statistics output by index AMs */
337
338 /* Instrumentation counters */
342 /* Counters that follow are only for scanned_pages */
349
350 /* State maintained by heap_vac_scan_next_block() */
355
356 /* State related to managing eager scanning of all-visible pages */
357
358 /*
359 * A normal vacuum that has failed to freeze too many eagerly scanned
360 * blocks in a region suspends eager scanning.
361 * next_eager_scan_region_start is the block number of the first block
362 * eligible for resumed eager scanning.
363 *
364 * When eager scanning is permanently disabled, either initially
365 * (including for aggressive vacuum) or due to hitting the success cap,
366 * this is set to InvalidBlockNumber.
367 */
369
370 /*
371 * The remaining number of blocks a normal vacuum will consider eager
372 * scanning when it is successful. When eager scanning is enabled, this is
373 * initialized to MAX_EAGER_FREEZE_SUCCESS_RATE of the total number of
374 * all-visible but not all-frozen pages. For each eager freeze success,
375 * this is decremented. Once it hits 0, eager scanning is permanently
376 * disabled. It is initialized to 0 if eager scanning starts out disabled
377 * (including for aggressive vacuum).
378 */
380
381 /*
382 * The maximum number of blocks which may be eagerly scanned and not
383 * frozen before eager scanning is temporarily suspended. This is
384 * configurable both globally, via the
385 * vacuum_max_eager_freeze_failure_rate GUC, and per table, with a table
386 * storage parameter of the same name. It is calculated as
387 * vacuum_max_eager_freeze_failure_rate of EAGER_SCAN_REGION_SIZE blocks.
388 * It is 0 when eager scanning is disabled.
389 */
391
392 /*
393 * The number of eagerly scanned blocks vacuum failed to freeze (due to
394 * age) in the current eager scan region. Vacuum resets it to
395 * eager_scan_max_fails_per_region each time it enters a new region of the
396 * relation. If eager_scan_remaining_fails hits 0, eager scanning is
397 * suspended until the next region. It is also 0 if eager scanning has
398 * been permanently disabled.
399 */
401} LVRelState;
402
403
404/* Struct for saving and restoring vacuum error information. */
406{
410} LVSavedErrInfo;
411
412
413/* non-export function prototypes */
418 void *callback_private_data,
419 void *per_buffer_data);
427 Buffer vmbuffer,
431 Buffer vmbuffer,
445 IndexBulkDeleteResult *istat,
446 double reltuples,
449 IndexBulkDeleteResult *istat,
450 double reltuples,
451 bool estimated_count,
462
463#ifdef USE_ASSERT_CHECKING
465 TransactionId OldestXmin,
466 bool *all_frozen,
467 TransactionId *visibility_cutoff_xid,
469#endif
471 TransactionId OldestXmin,
472 OffsetNumber *deadoffsets,
474 bool *all_frozen,
475 TransactionId *visibility_cutoff_xid,
482 OffsetNumber offnum);
485
486
487
488/*
489 * Helper to set up the eager scanning state for vacuuming a single relation.
490 * Initializes the eager scan management related members of the LVRelState.
491 *
492 * Caller provides whether or not an aggressive vacuum is required due to
493 * vacuum options or for relfrozenxid/relminmxid advancement.
494 */
495static void
497{
503
504 /*
505 * Initialize eager scan management fields to their disabled values.
506 * Aggressive vacuums, normal vacuums of small tables, and normal vacuums
507 * of tables without sufficiently old tuples disable eager scanning.
508 */
510 vacrel->eager_scan_max_fails_per_region = 0;
511 vacrel->eager_scan_remaining_fails = 0;
512 vacrel->eager_scan_remaining_successes = 0;
513
514 /* If eager scanning is explicitly disabled, just return. */
516 return;
517
518 /*
519 * The caller will have determined whether or not an aggressive vacuum is
520 * required by either the vacuum parameters or the relative age of the
521 * oldest unfrozen transaction IDs. An aggressive vacuum must scan every
522 * all-visible page to safely advance the relfrozenxid and/or relminmxid,
523 * so scans of all-visible pages are not considered eager.
524 */
526 return;
527
528 /*
529 * Aggressively vacuuming a small relation shouldn't take long, so it
530 * isn't worth amortizing. We use two times the region size as the size
531 * cutoff because the eager scan start block is a random spot somewhere in
532 * the first region, making the second region the first to be eager
533 * scanned normally.
534 */
536 return;
537
538 /*
539 * We only want to enable eager scanning if we are likely to be able to
540 * freeze some of the pages in the relation.
541 *
542 * Tuples with XIDs older than OldestXmin or MXIDs older than OldestMxact
543 * are technically freezable, but we won't freeze them unless the criteria
544 * for opportunistic freezing is met. Only tuples with XIDs/MXIDs older
545 * than the FreezeLimit/MultiXactCutoff are frozen in the common case.
546 *
547 * So, as a heuristic, we wait until the FreezeLimit has advanced past the
548 * relfrozenxid or the MultiXactCutoff has advanced past the relminmxid to
549 * enable eager scanning.
550 */
553 vacrel->cutoffs.FreezeLimit))
555
559 vacrel->cutoffs.MultiXactCutoff))
561
563 return;
564
565 /* We have met the criteria to eagerly scan some pages. */
566
567 /*
568 * Our success cap is MAX_EAGER_FREEZE_SUCCESS_RATE of the number of
569 * all-visible but not all-frozen blocks in the relation.
570 */
572
573 vacrel->eager_scan_remaining_successes =
576
577 /* If every all-visible page is frozen, eager scanning is disabled. */
579 return;
580
581 /*
582 * Now calculate the bounds of the first eager scan region. Its end block
583 * will be a random spot somewhere in the first EAGER_SCAN_REGION_SIZE
584 * blocks. This affects the bounds of all subsequent regions and avoids
585 * eager scanning and failing to freeze the same blocks each vacuum of the
586 * relation.
587 */
589
591
593 params.max_eager_freeze_failure_rate <= 1);
594
595 vacrel->eager_scan_max_fails_per_region =
596 params.max_eager_freeze_failure_rate *
598
599 /*
600 * The first region will be smaller than subsequent regions. As such,
601 * adjust the eager freeze failures tolerated for this region.
602 */
605
606 vacrel->eager_scan_remaining_fails =
607 vacrel->eager_scan_max_fails_per_region *
608 first_region_ratio;
609}
610
611/*
612 * heap_vacuum_rel() -- perform VACUUM for one heap relation
613 *
614 * This routine sets things up for and then calls lazy_scan_heap, where
615 * almost all work actually takes place. Finalizes everything after call
616 * returns by managing relation truncation and updating rel's pg_class
617 * entry. (Also updates pg_class entries for any indexes that need it.)
618 *
619 * At entry, we have already established a transaction and opened
620 * and locked the relation.
621 */
622void
624 BufferAccessStrategy bstrategy)
625{
628 instrument,
629 skipwithvm,
630 frozenxid_updated,
631 minmulti_updated;
633 new_rel_pages,
634 new_rel_allvisible,
635 new_rel_allfrozen;
637 TimestampTz starttime = 0;
639 startwritetime = 0;
642 ErrorContextCallback errcallback;
645
648 params.log_vacuum_min_duration >= 0));
649 if (instrument)
650 {
653 {
656 }
657 }
658
659 /* Used for instrumentation and stats report */
660 starttime = GetCurrentTimestamp();
661
663 RelationGetRelid(rel));
666 params.is_wraparound
669 else
672
673 /*
674 * Setup error traceback support for ereport() first. The idea is to set
675 * up an error context callback to display additional information on any
676 * error during a vacuum. During different phases of vacuum, we update
677 * the state so that the error context callback always display current
678 * information.
679 *
680 * Copy the names of heap rel into local memory for error reporting
681 * purposes, too. It isn't always safe to assume that we can get the name
682 * of each rel. It's convenient for code in lazy_scan_heap to always use
683 * these temp copies.
684 */
695 error_context_stack = &errcallback;
696
697 /* Set up high level stuff about rel and its indexes */
698 vacrel->rel = rel;
700 &vacrel->indrels);
701 vacrel->bstrategy = bstrategy;
703 {
704 /* Copy index names used by instrumentation (not error reporting) */
708 }
709
710 /*
711 * The index_cleanup param either disables index vacuuming and cleanup or
712 * forces it to go ahead when we would otherwise apply the index bypass
713 * optimization. The default is 'auto', which leaves the final decision
714 * up to lazy_vacuum().
715 *
716 * The truncate param allows user to avoid attempting relation truncation,
717 * though it can't force truncation to happen.
718 */
722
723 /*
724 * While VacuumFailSafeActive is reset to false before calling this, we
725 * still need to reset it here due to recursive calls.
726 */
733 {
734 /* Force disable index vacuuming up-front */
737 }
739 {
740 /* Force index vacuuming. Note that failsafe can still bypass. */
742 }
743 else
744 {
745 /* Default/auto, make all decisions dynamically */
747 }
748
749 /* Initialize page counters explicitly (be tidy) */
750 vacrel->scanned_pages = 0;
751 vacrel->eager_scanned_pages = 0;
752 vacrel->removed_pages = 0;
753 vacrel->new_frozen_tuple_pages = 0;
754 vacrel->lpdead_item_pages = 0;
755 vacrel->missed_dead_pages = 0;
756 vacrel->nonempty_pages = 0;
757 /* dead_items_alloc allocates vacrel->dead_items later on */
758
759 /* Allocate/initialize output statistics state */
760 vacrel->new_rel_tuples = 0;
761 vacrel->new_live_tuples = 0;
764
765 /* Initialize remaining counters (be tidy) */
766 vacrel->num_index_scans = 0;
767 vacrel->num_dead_items_resets = 0;
768 vacrel->total_dead_items_bytes = 0;
769 vacrel->tuples_deleted = 0;
770 vacrel->tuples_frozen = 0;
771 vacrel->lpdead_items = 0;
772 vacrel->live_tuples = 0;
773 vacrel->recently_dead_tuples = 0;
774 vacrel->missed_dead_tuples = 0;
775
776 vacrel->vm_new_visible_pages = 0;
777 vacrel->vm_new_visible_frozen_pages = 0;
778 vacrel->vm_new_frozen_pages = 0;
779
780 /*
781 * Get cutoffs that determine which deleted tuples are considered DEAD,
782 * not just RECENTLY_DEAD, and which XIDs/MXIDs to freeze. Then determine
783 * the extent of the blocks that we'll scan in lazy_scan_heap. It has to
784 * happen in this order to ensure that the OldestXmin cutoff field works
785 * as an upper bound on the XIDs stored in the pages we'll actually scan
786 * (NewRelfrozenXid tracking must never be allowed to miss unfrozen XIDs).
787 *
788 * Next acquire vistest, a related cutoff that's used in pruning. We use
789 * vistest in combination with OldestXmin to ensure that
790 * heap_page_prune_and_freeze() always removes any deleted tuple whose
791 * xmax is < OldestXmin. lazy_scan_prune must never become confused about
792 * whether a tuple should be frozen or removed. (In the future we might
793 * want to teach lazy_scan_prune to recompute vistest from time to time,
794 * to increase the number of dead tuples it can prune away.)
795 */
799
800 /* Initialize state used to track oldest extant XID/MXID */
803
804 /*
805 * Initialize state related to tracking all-visible page skipping. This is
806 * very important to determine whether or not it is safe to advance the
807 * relfrozenxid/relminmxid.
808 */
810 skipwithvm = true;
812 {
813 /*
814 * Force aggressive mode, and disable skipping blocks using the
815 * visibility map (even those set all-frozen)
816 */
818 skipwithvm = false;
819 }
820
821 vacrel->skipwithvm = skipwithvm;
822
823 /*
824 * Set up eager scan tracking state. This must happen after determining
825 * whether or not the vacuum must be aggressive, because only normal
826 * vacuums use the eager scan algorithm.
827 */
829
830 /* Report the vacuum mode: 'normal' or 'aggressive' */
832 vacrel->aggressive
834 : PROGRESS_VACUUM_MODE_NORMAL);
835
837 {
842 vacrel->relname)));
843 else
847 vacrel->relname)));
848 }
849
850 /*
851 * Allocate dead_items memory using dead_items_alloc. This handles
852 * parallel VACUUM initialization as part of allocating shared memory
853 * space used for dead_items. (But do a failsafe precheck first, to
854 * ensure that parallel VACUUM won't be attempted at all when relfrozenxid
855 * is already dangerously old.)
856 */
859
860 /*
861 * Call lazy_scan_heap to perform all required heap pruning, index
862 * vacuuming, and heap vacuuming (plus related processing)
863 */
865
866 /*
867 * Save dead items max_bytes and update the memory usage statistics before
868 * cleanup, they are freed in parallel vacuum cases during
869 * dead_items_cleanup().
870 */
873
874 /*
875 * Free resources managed by dead_items_alloc. This ends parallel mode in
876 * passing when necessary.
877 */
880
881 /*
882 * Update pg_class entries for each of rel's indexes where appropriate.
883 *
884 * Unlike the later update to rel's pg_class entry, this is not critical.
885 * Maintains relpages/reltuples statistics used by the planner only.
886 */
889
890 /* Done with rel's indexes */
892
893 /* Optionally truncate rel */
896
897 /* Pop the error context stack */
899
900 /* Report that we are now doing final cleanup */
903
904 /*
905 * Prepare to update rel's pg_class entry.
906 *
907 * Aggressive VACUUMs must always be able to advance relfrozenxid to a
908 * value >= FreezeLimit, and relminmxid to a value >= MultiXactCutoff.
909 * Non-aggressive VACUUMs may advance them by any amount, or not at all.
910 */
913 vacrel->cutoffs.relfrozenxid,
914 vacrel->NewRelfrozenXid));
917 vacrel->cutoffs.relminmxid,
918 vacrel->NewRelminMxid));
920 {
921 /*
922 * Must keep original relfrozenxid in a non-aggressive VACUUM that
923 * chose to skip an all-visible page range. The state that tracks new
924 * values will have missed unfrozen XIDs from the pages we skipped.
925 */
929 }
930
931 /*
932 * For safety, clamp relallvisible to be not more than what we're setting
933 * pg_class.relpages to
934 */
939
940 /*
941 * An all-frozen block _must_ be all-visible. As such, clamp the count of
942 * all-frozen blocks to the count of all-visible blocks. This matches the
943 * clamping of relallvisible above.
944 */
947
948 /*
949 * Now actually update rel's pg_class entry.
950 *
951 * In principle new_live_tuples could be -1 indicating that we (still)
952 * don't know the tuple count. In practice that can't happen, since we
953 * scan every page that isn't skipped using the visibility map.
954 */
957 vacrel->nindexes > 0,
960
961 /*
962 * Report results to the cumulative stats system, too.
963 *
964 * Deliberately avoid telling the stats system about LP_DEAD items that
965 * remain in the table due to VACUUM bypassing index and heap vacuuming.
966 * ANALYZE will consider the remaining LP_DEAD items to be dead "tuples".
967 * It seems like a good idea to err on the side of not vacuuming again too
968 * soon in cases where the failsafe prevented significant amounts of heap
969 * vacuuming.
970 */
971 pgstat_report_vacuum(rel,
973 vacrel->recently_dead_tuples +
974 vacrel->missed_dead_tuples,
975 starttime);
976 pgstat_progress_end_command();
977
978 if (instrument)
979 {
981
984 params.log_vacuum_min_duration))
985 {
988 WalUsage walusage;
989 BufferUsage bufferusage;
994 write_rate = 0;
998
1004
1006 bufferusage.local_blks_hit;
1008 bufferusage.local_blks_read;
1010 bufferusage.local_blks_dirtied;
1011
1014 {
1015 /*
1016 * Aggressiveness already reported earlier, in dedicated
1017 * VACUUM VERBOSE ereport
1018 */
1021 }
1023 {
1024 /*
1025 * While it's possible for a VACUUM to be both is_wraparound
1026 * and !aggressive, that's just a corner-case -- is_wraparound
1027 * implies aggressive. Produce distinct output for the corner
1028 * case all the same, just in case.
1029 */
1031 msgfmt = _("automatic aggressive vacuum to prevent wraparound of table \"%s.%s.%s\": index scans: %d\n");
1032 else
1034 }
1035 else
1036 {
1039 else
1041 }
1043 vacrel->dbname,
1044 vacrel->relnamespace,
1045 vacrel->relname,
1046 vacrel->num_index_scans);
1047 appendStringInfo(&buf, _("pages: %u removed, %u remain, %u scanned (%.2f%% of total), %u eagerly scanned\n"),
1048 vacrel->removed_pages,
1049 new_rel_pages,
1050 vacrel->scanned_pages,
1051 orig_rel_pages == 0 ? 100.0 :
1052 100.0 * vacrel->scanned_pages /
1053 orig_rel_pages,
1054 vacrel->eager_scanned_pages);
1056 _("tuples: %" PRId64 " removed, %" PRId64 " remain, %" PRId64 " are dead but not yet removable\n"),
1057 vacrel->tuples_deleted,
1059 vacrel->recently_dead_tuples);
1062 _("tuples missed: %" PRId64 " dead from %u pages not removed due to cleanup lock contention\n"),
1063 vacrel->missed_dead_tuples,
1064 vacrel->missed_dead_pages);
1066 vacrel->cutoffs.OldestXmin);
1071 {
1073 vacrel->cutoffs.relfrozenxid);
1077 }
1079 {
1081 vacrel->cutoffs.relminmxid);
1085 }
1086 appendStringInfo(&buf, _("frozen: %u pages from table (%.2f%% of total) had %" PRId64 " tuples frozen\n"),
1087 vacrel->new_frozen_tuple_pages,
1088 orig_rel_pages == 0 ? 100.0 :
1089 100.0 * vacrel->new_frozen_tuple_pages /
1090 orig_rel_pages,
1091 vacrel->tuples_frozen);
1092
1094 _("visibility map: %u pages set all-visible, %u pages set all-frozen (%u were all-visible)\n"),
1095 vacrel->vm_new_visible_pages,
1096 vacrel->vm_new_visible_frozen_pages +
1097 vacrel->vm_new_frozen_pages,
1098 vacrel->vm_new_frozen_pages);
1100 {
1103 else
1105
1106 msgfmt = _("%u pages from table (%.2f%% of total) had %" PRId64 " dead item identifiers removed\n");
1107 }
1108 else
1109 {
1112 else
1114
1116 }
1118 vacrel->lpdead_item_pages,
1119 orig_rel_pages == 0 ? 100.0 :
1121 vacrel->lpdead_items);
1123 {
1125
1126 if (!istat)
1127 continue;
1128
1132 istat->num_pages,
1133 istat->pages_newly_deleted,
1134 istat->pages_deleted,
1135 istat->pages_free);
1136 }
1138 {
1139 /*
1140 * We bypass the changecount mechanism because this value is
1141 * only updated by the calling process. We also rely on the
1142 * above call to pgstat_progress_end_command() to not clear
1143 * the st_progress_param array.
1144 */
1147 }
1149 {
1152
1155 }
1157 {
1162 }
1167 total_blks_hit,
1168 total_blks_read,
1169 total_blks_dirtied);
1171 _("WAL usage: %" PRId64 " records, %" PRId64 " full page images, %" PRIu64 " bytes, %" PRIu64 " full page image bytes, %" PRId64 " buffers full\n"),
1172 walusage.wal_records,
1173 walusage.wal_fpi,
1174 walusage.wal_bytes,
1175 walusage.wal_fpi_bytes,
1176 walusage.wal_buffers_full);
1177
1178 /*
1179 * Report the dead items memory usage.
1180 *
1181 * The num_dead_items_resets counter increases when we reset the
1182 * collected dead items, so the counter is non-zero if at least
1183 * one dead items are collected, even if index vacuuming is
1184 * disabled.
1185 */
1187 ngettext("memory usage: dead item storage %.2f MB accumulated across %d reset (limit %.2f MB each)\n",
1188 "memory usage: dead item storage %.2f MB accumulated across %d resets (limit %.2f MB each)\n",
1189 vacrel->num_dead_items_resets),
1191 vacrel->num_dead_items_resets,
1194
1198 }
1199 }
1200
1201 /* Cleanup index statistics and index names */
1203 {
1206
1207 if (instrument)
1209 }
1210}
1211
1212/*
1213 * lazy_scan_heap() -- workhorse function for VACUUM
1214 *
1215 * This routine prunes each page in the heap, and considers the need to
1216 * freeze remaining tuples with storage (not including pages that can be
1217 * skipped using the visibility map). Also performs related maintenance
1218 * of the FSM and visibility map. These steps all take place during an
1219 * initial pass over the target heap relation.
1220 *
1221 * Also invokes lazy_vacuum_all_indexes to vacuum indexes, which largely
1222 * consists of deleting index tuples that point to LP_DEAD items left in
1223 * heap pages following pruning. Earlier initial pass over the heap will
1224 * have collected the TIDs whose index tuples need to be removed.
1225 *
1226 * Finally, invokes lazy_vacuum_heap_rel to vacuum heap pages, which
1227 * largely consists of marking LP_DEAD items (from vacrel->dead_items)
1228 * as LP_UNUSED. This has to happen in a second, final pass over the
1229 * heap, to preserve a basic invariant that all index AMs rely on: no
1230 * extant index tuple can ever be allowed to contain a TID that points to
1231 * an LP_UNUSED line pointer in the heap. We must disallow premature
1232 * recycling of line pointers to avoid index scans that get confused
1233 * about which TID points to which tuple immediately after recycling.
1234 * (Actually, this isn't a concern when target heap relation happens to
1235 * have no indexes, which allows us to safely apply the one-pass strategy
1236 * as an optimization).
1237 *
1238 * In practice we often have enough space to fit all TIDs, and so won't
1239 * need to call lazy_vacuum more than once, after our initial pass over
1240 * the heap has totally finished. Otherwise things are slightly more
1241 * complicated: our "initial pass" over the heap applies only to those
1242 * pages that were pruned before we needed to call lazy_vacuum, and our
1243 * "final pass" over the heap only vacuums these same heap pages.
1244 * However, we process indexes in full every time lazy_vacuum is called,
1245 * which makes index processing very inefficient when memory is in short
1246 * supply.
1247 */
1248static void
1250{
1251 ReadStream *stream;
1253 blkno = 0,
1254 next_fsm_block_to_vacuum = 0;
1259 PROGRESS_VACUUM_PHASE,
1262 };
1264
1265 /* Report that we're scanning the heap, advertising total # of blocks */
1267 initprog_val[1] = rel_pages;
1270
1271 /* Initialize for the first heap_vac_scan_next_block() call */
1276
1277 /*
1278 * Set up the read stream for vacuum's first pass through the heap.
1279 *
1280 * This could be made safe for READ_STREAM_USE_BATCHING, but only with
1281 * explicit work in heap_vac_scan_next_block.
1282 */
1284 vacrel->bstrategy,
1285 vacrel->rel,
1286 MAIN_FORKNUM,
1287 heap_vac_scan_next_block,
1288 vacrel,
1289 sizeof(bool));
1290
1291 while (true)
1292 {
1294 Page page;
1296 int ndeleted = 0;
1301
1303
1304 /*
1305 * Regularly check if wraparound failsafe should trigger.
1306 *
1307 * There is a similar check inside lazy_vacuum_all_indexes(), but
1308 * relfrozenxid might start to look dangerously old before we reach
1309 * that point. This check also provides failsafe coverage for the
1310 * one-pass strategy, and the two-pass strategy with the index_cleanup
1311 * param set to 'off'.
1312 */
1316
1317 /*
1318 * Consider if we definitely have enough space to process TIDs on page
1319 * already. If we are close to overrunning the available space for
1320 * dead_items TIDs, pause and do a cycle of vacuuming before we tackle
1321 * this page. However, let's force at least one page-worth of tuples
1322 * to be stored as to ensure we do at least some work when the memory
1323 * configured is so low that we run out before storing anything.
1324 */
1327 {
1328 /*
1329 * Before beginning index vacuuming, we release any pin we may
1330 * hold on the visibility map page. This isn't necessary for
1331 * correctness, but we do it anyway to avoid holding the pin
1332 * across a lengthy, unrelated operation.
1333 */
1335 {
1336 ReleaseBuffer(vmbuffer);
1337 vmbuffer = InvalidBuffer;
1338 }
1339
1340 /* Perform a round of index and heap vacuuming */
1343
1344 /*
1345 * Vacuum the Free Space Map to make newly-freed space visible on
1346 * upper-level FSM pages. Note that blkno is the previously
1347 * processed block.
1348 */
1350 blkno + 1);
1351 next_fsm_block_to_vacuum = blkno;
1352
1353 /* Report that we are once again scanning the heap */
1356 }
1357
1359
1360 /* The relation is exhausted. */
1362 break;
1363
1368
1369 vacrel->scanned_pages++;
1371 vacrel->eager_scanned_pages++;
1372
1373 /* Report as block scanned, update error traceback information */
1376 blkno, InvalidOffsetNumber);
1377
1378 /*
1379 * Pin the visibility map page in case we need to mark the page
1380 * all-visible. In most cases this will be very cheap, because we'll
1381 * already have the correct page pinned anyway.
1382 */
1384
1385 /*
1386 * We need a buffer cleanup lock to prune HOT chains and defragment
1387 * the page in lazy_scan_prune. But when it's not possible to acquire
1388 * a cleanup lock right away, we may be able to settle for reduced
1389 * processing using lazy_scan_noprune.
1390 */
1392
1395
1396 /* Check for new or empty pages before lazy_scan_[no]prune call */
1398 vmbuffer))
1399 {
1400 /* Processed as new/empty page (lock and pin released) */
1401 continue;
1402 }
1403
1404 /*
1405 * If we didn't get the cleanup lock, we can still collect LP_DEAD
1406 * items in the dead_items area for later vacuuming, count live and
1407 * recently dead tuples for vacuum logging, and determine if this
1408 * block could later be truncated. If we encounter any xid/mxids that
1409 * require advancing the relfrozenxid/relminxid, we'll have to wait
1410 * for a cleanup lock and call lazy_scan_prune().
1411 */
1414 {
1415 /*
1416 * lazy_scan_noprune could not do all required processing. Wait
1417 * for a cleanup lock, and call lazy_scan_prune in the usual way.
1418 */
1423 }
1424
1425 /*
1426 * If we have a cleanup lock, we must now prune, freeze, and count
1427 * tuples. We may have acquired the cleanup lock originally, or we may
1428 * have gone back and acquired it after lazy_scan_noprune() returned
1429 * false. Either way, the page hasn't been processed yet.
1430 *
1431 * Like lazy_scan_noprune(), lazy_scan_prune() will count
1432 * recently_dead_tuples and live tuples for vacuum logging, determine
1433 * if the block can later be truncated, and accumulate the details of
1434 * remaining LP_DEAD line pointers on the page into dead_items. These
1435 * dead items include those pruned by lazy_scan_prune() as well as
1436 * line pointers previously marked LP_DEAD.
1437 */
1440 vmbuffer,
1442
1443 /*
1444 * Count an eagerly scanned page as a failure or a success.
1445 *
1446 * Only lazy_scan_prune() freezes pages, so if we didn't get the
1447 * cleanup lock, we won't have frozen the page. However, we only count
1448 * pages that were too new to require freezing as eager freeze
1449 * failures.
1450 *
1451 * We could gather more information from lazy_scan_noprune() about
1452 * whether or not there were tuples with XIDs or MXIDs older than the
1453 * FreezeLimit or MultiXactCutoff. However, for simplicity, we simply
1454 * exclude pages skipped due to cleanup lock contention from eager
1455 * freeze algorithm caps.
1456 */
1458 {
1459 /* Aggressive vacuums do not eager scan. */
1461
1463 {
1465 vacrel->eager_scan_remaining_successes--;
1466
1468 {
1469 /*
1470 * Report only once that we disabled eager scanning. We
1471 * may eagerly read ahead blocks in excess of the success
1472 * or failure caps before attempting to freeze them, so we
1473 * could reach here even after disabling additional eager
1474 * scanning.
1475 */
1478 (errmsg("disabling eager scanning after freezing %u eagerly scanned blocks of relation \"%s.%s.%s\"",
1482
1483 /*
1484 * If we hit our success cap, permanently disable eager
1485 * scanning by setting the other eager scan management
1486 * fields to their disabled values.
1487 */
1488 vacrel->eager_scan_remaining_fails = 0;
1490 vacrel->eager_scan_max_fails_per_region = 0;
1491 }
1492 }
1494 vacrel->eager_scan_remaining_fails--;
1495 }
1496
1497 /*
1498 * Now drop the buffer lock and, potentially, update the FSM.
1499 *
1500 * Our goal is to update the freespace map the last time we touch the
1501 * page. If we'll process a block in the second pass, we may free up
1502 * additional space on the page, so it is better to update the FSM
1503 * after the second pass. If the relation has no indexes, or if index
1504 * vacuuming is disabled, there will be no second heap pass; if this
1505 * particular page has no dead items, the second heap pass will not
1506 * touch this page. So, in those cases, update the FSM now.
1507 *
1508 * Note: In corner cases, it's possible to miss updating the FSM
1509 * entirely. If index vacuuming is currently enabled, we'll skip the
1510 * FSM update now. But if failsafe mode is later activated, or there
1511 * are so few dead tuples that index vacuuming is bypassed, there will
1512 * also be no opportunity to update the FSM later, because we'll never
1513 * revisit this page. Since updating the FSM is desirable but not
1514 * absolutely required, that's OK.
1515 */
1517 || !vacrel->do_index_vacuuming
1518 || !has_lpdead_items)
1519 {
1521
1524
1525 /*
1526 * Periodically perform FSM vacuuming to make newly-freed space
1527 * visible on upper FSM pages. This is done after vacuuming if the
1528 * table has indexes. There will only be newly-freed space if we
1529 * held the cleanup lock and lazy_scan_prune() was called.
1530 */
1533 {
1535 blkno);
1536 next_fsm_block_to_vacuum = blkno;
1537 }
1538 }
1539 else
1541 }
1542
1545 ReleaseBuffer(vmbuffer);
1546
1547 /*
1548 * Report that everything is now scanned. We never skip scanning the last
1549 * block in the relation, so we can pass rel_pages here.
1550 */
1552 rel_pages);
1553
1554 /* now we can compute the new value for pg_class.reltuples */
1556 vacrel->scanned_pages,
1557 vacrel->live_tuples);
1558
1559 /*
1560 * Also compute the total number of surviving heap entries. In the
1561 * (unlikely) scenario that new_live_tuples is -1, take it as zero.
1562 */
1563 vacrel->new_rel_tuples =
1565 vacrel->missed_dead_tuples;
1566
1567 read_stream_end(stream);
1568
1569 /*
1570 * Do index vacuuming (call each index's ambulkdelete routine), then do
1571 * related heap vacuuming
1572 */
1575
1576 /*
1577 * Vacuum the remainder of the Free Space Map. We must do this whether or
1578 * not there were indexes, and whether or not we bypassed index vacuuming.
1579 * We can pass rel_pages here because we never skip scanning the last
1580 * block of the relation.
1581 */
1584
1585 /* report all blocks vacuumed */
1587
1588 /* Do final index cleanup (call each index's amvacuumcleanup routine) */
1591}
1592
1593/*
1594 * heap_vac_scan_next_block() -- read stream callback to get the next block
1595 * for vacuum to process
1596 *
1597 * Every time lazy_scan_heap() needs a new block to process during its first
1598 * phase, it invokes read_stream_next_buffer() with a stream set up to call
1599 * heap_vac_scan_next_block() to get the next block.
1600 *
1601 * heap_vac_scan_next_block() uses the visibility map, vacuum options, and
1602 * various thresholds to skip blocks which do not need to be processed and
1603 * returns the next block to process or InvalidBlockNumber if there are no
1604 * remaining blocks.
1605 *
1606 * The visibility status of the next block to process and whether or not it
1607 * was eager scanned is set in the per_buffer_data.
1608 *
1609 * callback_private_data contains a reference to the LVRelState, passed to the
1610 * read stream API during stream setup. The LVRelState is an in/out parameter
1611 * here (locally named `vacrel`). Vacuum options and information about the
1612 * relation are read from it. vacrel->skippedallvis is set if we skip a block
1613 * that's all-visible but not all-frozen (to ensure that we don't update
1614 * relfrozenxid in that case). vacrel also holds information about the next
1615 * unskippable block -- as bookkeeping for this function.
1616 */
1619 void *callback_private_data,
1620 void *per_buffer_data)
1621{
1624
1625 /* relies on InvalidBlockNumber + 1 overflowing to 0 on first call */
1627
1628 /* Have we reached the end of the relation? */
1630 {
1632 {
1635 }
1637 }
1638
1639 /*
1640 * We must be in one of the three following states:
1641 */
1644 {
1645 /*
1646 * 1. We have just processed an unskippable block (or we're at the
1647 * beginning of the scan). Find the next unskippable block using the
1648 * visibility map.
1649 */
1651
1653
1654 /*
1655 * We now know the next block that we must process. It can be the
1656 * next block after the one we just processed, or something further
1657 * ahead. If it's further ahead, we can jump to it, but we choose to
1658 * do so only if we can skip at least SKIP_PAGES_THRESHOLD consecutive
1659 * pages. Since we're reading sequentially, the OS should be doing
1660 * readahead for us, so there's no gain in skipping a page now and
1661 * then. Skipping such a range might even discourage sequential
1662 * detection.
1663 *
1664 * This test also enables more frequent relfrozenxid advancement
1665 * during non-aggressive VACUUMs. If the range has any all-visible
1666 * pages then skipping makes updating relfrozenxid unsafe, which is a
1667 * real downside.
1668 */
1670 {
1674 }
1675 }
1676
1677 /* Now we must be in one of the two remaining states: */
1679 {
1680 /*
1681 * 2. We are processing a range of blocks that we could have skipped
1682 * but chose not to. We know that they are all-visible in the VM,
1683 * otherwise they would've been unskippable.
1684 */
1686 /* Block was not eager scanned */
1687 *((bool *) per_buffer_data) = false;
1689 }
1690 else
1691 {
1692 /*
1693 * 3. We reached the next unskippable block. Process it. On next
1694 * iteration, we will be back in state 1.
1695 */
1697
1701 }
1702}
1703
1704/*
1705 * Find the next unskippable block in a vacuum scan using the visibility map.
1706 * The next unskippable block and its visibility information is updated in
1707 * vacrel.
1708 *
1709 * Note: our opinion of which blocks can be skipped can go stale immediately.
1710 * It's okay if caller "misses" a page whose all-visible or all-frozen marking
1711 * was concurrently cleared, though. All that matters is that caller scan all
1712 * pages whose tuples might contain XIDs < OldestXmin, or MXIDs < OldestMxact.
1713 * (Actually, non-aggressive VACUUMs can choose to skip all-visible pages with
1714 * older XIDs/MXIDs. The *skippedallvis flag will be set here when the choice
1715 * to skip such a range is actually made, making everything safe.)
1716 */
1717static void
1719{
1723 bool next_unskippable_eager_scanned = false;
1724
1726
1727 for (;; next_unskippable_block++)
1728 {
1730 next_unskippable_block,
1731 &next_unskippable_vmbuffer);
1732
1733
1734 /*
1735 * At the start of each eager scan region, normal vacuums with eager
1736 * scanning enabled reset the failure counter, allowing vacuum to
1737 * resume eager scanning if it had been suspended in the previous
1738 * region.
1739 */
1741 {
1742 vacrel->eager_scan_remaining_fails =
1743 vacrel->eager_scan_max_fails_per_region;
1745 }
1746
1747 /*
1748 * A block is unskippable if it is not all visible according to the
1749 * visibility map.
1750 */
1752 {
1754 break;
1755 }
1756
1757 /*
1758 * Caller must scan the last page to determine whether it has tuples
1759 * (caller must have the opportunity to set vacrel->nonempty_pages).
1760 * This rule avoids having lazy_truncate_heap() take access-exclusive
1761 * lock on rel to attempt a truncation that fails anyway, just because
1762 * there are tuples on the last page (it is likely that there will be
1763 * tuples on other nearby pages as well, but those can be skipped).
1764 *
1765 * Implement this by always treating the last block as unsafe to skip.
1766 */
1767 if (next_unskippable_block == rel_pages - 1)
1768 break;
1769
1770 /* DISABLE_PAGE_SKIPPING makes all skipping unsafe */
1772 break;
1773
1774 /*
1775 * All-frozen pages cannot contain XIDs < OldestXmin (XIDs that aren't
1776 * already frozen by now), so this page can be skipped.
1777 */
1779 continue;
1780
1781 /*
1782 * Aggressive vacuums cannot skip any all-visible pages that are not
1783 * also all-frozen.
1784 */
1786 break;
1787
1788 /*
1789 * Normal vacuums with eager scanning enabled only skip all-visible
1790 * but not all-frozen pages if they have hit the failure limit for the
1791 * current eager scan region.
1792 */
1794 {
1795 next_unskippable_eager_scanned = true;
1796 break;
1797 }
1798
1799 /*
1800 * All-visible blocks are safe to skip in a normal vacuum. But
1801 * remember that the final range contains such a block for later.
1802 */
1804 }
1805
1806 /* write the local variables back to vacrel */
1807 vacrel->next_unskippable_block = next_unskippable_block;
1808 vacrel->next_unskippable_eager_scanned = next_unskippable_eager_scanned;
1809 vacrel->next_unskippable_vmbuffer = next_unskippable_vmbuffer;
1810}
1811
1812/*
1813 * lazy_scan_new_or_empty() -- lazy_scan_heap() new/empty page handling.
1814 *
1815 * Must call here to handle both new and empty pages before calling
1816 * lazy_scan_prune or lazy_scan_noprune, since they're not prepared to deal
1817 * with new or empty pages.
1818 *
1819 * It's necessary to consider new pages as a special case, since the rules for
1820 * maintaining the visibility map and FSM with empty pages are a little
1821 * different (though new pages can be truncated away during rel truncation).
1822 *
1823 * Empty pages are not really a special case -- they're just heap pages that
1824 * have no allocated tuples (including even LP_UNUSED items). You might
1825 * wonder why we need to handle them here all the same. It's only necessary
1826 * because of a corner-case involving a hard crash during heap relation
1827 * extension. If we ever make relation-extension crash safe, then it should
1828 * no longer be necessary to deal with empty pages here (or new pages, for
1829 * that matter).
1830 *
1831 * Caller must hold at least a shared lock. We might need to escalate the
1832 * lock in that case, so the type of lock caller holds needs to be specified
1833 * using 'sharelock' argument.
1834 *
1835 * Returns false in common case where caller should go on to call
1836 * lazy_scan_prune (or lazy_scan_noprune). Otherwise returns true, indicating
1837 * that lazy_scan_heap is done processing the page, releasing lock on caller's
1838 * behalf.
1839 *
1840 * No vm_page_frozen output parameter (like that passed to lazy_scan_prune())
1841 * is passed here because neither empty nor new pages can be eagerly frozen.
1842 * New pages are never frozen. Empty pages are always set frozen in the VM at
1843 * the same time that they are set all-visible, and we don't eagerly scan
1844 * frozen pages.
1845 */
1846static bool
1849{
1850 Size freespace;
1851
1853 {
1854 /*
1855 * All-zeroes pages can be left over if either a backend extends the
1856 * relation by a single page, but crashes before the newly initialized
1857 * page has been written out, or when bulk-extending the relation
1858 * (which creates a number of empty pages at the tail end of the
1859 * relation), and then enters them into the FSM.
1860 *
1861 * Note we do not enter the page into the visibilitymap. That has the
1862 * downside that we repeatedly visit this page in subsequent vacuums,
1863 * but otherwise we'll never discover the space on a promoted standby.
1864 * The harm of repeated checking ought to normally not be too bad. The
1865 * space usually should be used at some point, otherwise there
1866 * wouldn't be any regular vacuums.
1867 *
1868 * Make sure these pages are in the FSM, to ensure they can be reused.
1869 * Do that by testing if there's any space recorded for the page. If
1870 * not, enter it. We do so after releasing the lock on the heap page,
1871 * the FSM is approximate, after all.
1872 */
1874
1876 {
1878
1880 }
1881
1882 return true;
1883 }
1884
1886 {
1887 /*
1888 * It seems likely that caller will always be able to get a cleanup
1889 * lock on an empty page. But don't take any chances -- escalate to
1890 * an exclusive lock (still don't need a cleanup lock, though).
1891 */
1893 {
1896
1898 {
1899 /* page isn't new or empty -- keep lock and pin for now */
1900 return false;
1901 }
1902 }
1903 else
1904 {
1905 /* Already have a full cleanup lock (which is more than enough) */
1906 }
1907
1908 /*
1909 * Unlike new pages, empty pages are always set all-visible and
1910 * all-frozen.
1911 */
1913 {
1914 START_CRIT_SECTION();
1915
1916 /* mark buffer dirty before writing a WAL record */
1918
1919 /*
1920 * It's possible that another backend has extended the heap,
1921 * initialized the page, and then failed to WAL-log the page due
1922 * to an ERROR. Since heap extension is not WAL-logged, recovery
1923 * might try to replay our record setting the page all-visible and
1924 * find that the page isn't initialized, which will cause a PANIC.
1925 * To prevent that, check whether the page has been previously
1926 * WAL-logged, and if not, do that now.
1927 */
1931
1932 PageSetAllVisible(page);
1934 InvalidXLogRecPtr,
1935 vmbuffer, InvalidTransactionId,
1936 VISIBILITYMAP_ALL_VISIBLE |
1937 VISIBILITYMAP_ALL_FROZEN);
1938 END_CRIT_SECTION();
1939
1940 /* Count the newly all-frozen pages for logging */
1941 vacrel->vm_new_visible_pages++;
1942 vacrel->vm_new_visible_frozen_pages++;
1943 }
1944
1945 freespace = PageGetHeapFreeSpace(page);
1948 return true;
1949 }
1950
1951 /* page isn't new or empty -- keep lock and pin */
1952 return false;
1953}
1954
1955/* qsort comparator for sorting OffsetNumbers */
1956static int
1958{
1960}
1961
1962/*
1963 * Helper to correct any corruption detected on a heap page and its
1964 * corresponding visibility map page after pruning but before setting the
1965 * visibility map. It examines the heap page, the associated VM page, and the
1966 * number of dead items previously identified.
1967 *
1968 * This function must be called while holding an exclusive lock on the heap
1969 * buffer, and the dead items must have been discovered under that same lock.
1970
1971 * The provided vmbits must reflect the current state of the VM block
1972 * referenced by vmbuffer. Although we do not hold a lock on the VM buffer, it
1973 * is pinned, and the heap buffer is exclusively locked, ensuring that no
1974 * other backend can update the VM bits corresponding to this heap page.
1975 *
1976 * If it clears corruption, it will zero out vmbits.
1977 */
1978static void
1982 Buffer vmbuffer,
1984{
1986
1988
1989 /*
1990 * As of PostgreSQL 9.2, the visibility map bit should never be set if the
1991 * page-level bit is clear. However, it's possible that the bit got
1992 * cleared after heap_vac_scan_next_block() was called, so we must recheck
1993 * with buffer lock before concluding that the VM is corrupt.
1994 */
1997 {
2000 errmsg("page is not marked all-visible but visibility map bit is set in relation \"%s\" page %u",
2002
2004 VISIBILITYMAP_VALID_BITS);
2005 *vmbits = 0;
2006 }
2007
2008 /*
2009 * It's possible for the value returned by
2010 * GetOldestNonRemovableTransactionId() to move backwards, so it's not
2011 * wrong for us to see tuples that appear to not be visible to everyone
2012 * yet, while PD_ALL_VISIBLE is already set. The real safe xmin value
2013 * never moves backwards, but GetOldestNonRemovableTransactionId() is
2014 * conservative and sometimes returns a value that's unnecessarily small,
2015 * so if we see that contradiction it just means that the tuples that we
2016 * think are not visible to everyone yet actually are, and the
2017 * PD_ALL_VISIBLE flag is correct.
2018 *
2019 * There should never be LP_DEAD items on a page with PD_ALL_VISIBLE set,
2020 * however.
2021 */
2023 {
2028
2032 VISIBILITYMAP_VALID_BITS);
2033 *vmbits = 0;
2034 }
2035}
2036
2037/*
2038 * lazy_scan_prune() -- lazy_scan_heap() pruning and freezing.
2039 *
2040 * Caller must hold pin and buffer cleanup lock on the buffer.
2041 *
2042 * vmbuffer is the buffer containing the VM block with visibility information
2043 * for the heap block, blkno.
2044 *
2045 * *has_lpdead_items is set to true or false depending on whether, upon return
2046 * from this function, any LP_DEAD items are still present on the page.
2047 *
2048 * *vm_page_frozen is set to true if the page is newly set all-frozen in the
2049 * VM. The caller currently only uses this for determining whether an eagerly
2050 * scanned page was successfully set all-frozen.
2051 *
2052 * Returns the number of tuples deleted from the page during HOT pruning.
2053 */
2054static int
2057 BlockNumber blkno,
2058 Page page,
2059 Buffer vmbuffer,
2062{
2065 PruneFreezeParams params = {
2066 .relation = rel,
2067 .buffer = buf,
2068 .reason = PRUNE_VACUUM_SCAN,
2069 .options = HEAP_PAGE_PRUNE_FREEZE,
2070 .vistest = vacrel->vistest,
2071 .cutoffs = &vacrel->cutoffs,
2072 };
2075
2077
2078 /*
2079 * Prune all HOT-update chains and potentially freeze tuples on this page.
2080 *
2081 * If the relation has no indexes, we can immediately mark would-be dead
2082 * items LP_UNUSED.
2083 *
2084 * The number of tuples removed from the page is returned in
2085 * presult.ndeleted. It should not be confused with presult.lpdead_items;
2086 * presult.lpdead_items's final value can be thought of as the number of
2087 * tuples that were deleted from indexes.
2088 *
2089 * We will update the VM after collecting LP_DEAD items and freezing
2090 * tuples. Pruning will have determined whether or not the page is
2091 * all-visible.
2092 */
2095
2096 heap_page_prune_and_freeze(¶ms,
2097 &presult,
2098 &vacrel->offnum,
2100
2103
2105 {
2106 /*
2107 * We don't increment the new_frozen_tuple_pages instrumentation
2108 * counter when nfrozen == 0, since it only counts pages with newly
2109 * frozen tuples (don't confuse that with pages newly set all-frozen
2110 * in VM).
2111 */
2112 vacrel->new_frozen_tuple_pages++;
2113 }
2114
2115 /*
2116 * VACUUM will call heap_page_is_all_visible() during the second pass over
2117 * the heap to determine all_visible and all_frozen for the page -- this
2118 * is a specialized version of the logic from this function. Now that
2119 * we've finished pruning and freezing, make sure that we're in total
2120 * agreement with heap_page_is_all_visible() using an assertion.
2121 */
2122#ifdef USE_ASSERT_CHECKING
2124 {
2127
2129
2133
2135
2138 }
2139#endif
2140
2141 /*
2142 * Now save details of the LP_DEAD items from the page in vacrel
2143 */
2145 {
2146 vacrel->lpdead_item_pages++;
2147
2148 /*
2149 * deadoffsets are collected incrementally in
2150 * heap_page_prune_and_freeze() as each dead line pointer is recorded,
2151 * with an indeterminate order, but dead_items_add requires them to be
2152 * sorted.
2153 */
2155 cmpOffsetNumbers);
2156
2158 }
2159
2160 /* Finally, add page-local counts to whole-VACUUM counts */
2166
2167 /* Can't truncate this page */
2169 vacrel->nonempty_pages = blkno + 1;
2170
2171 /* Did we find LP_DEAD items? */
2173
2176
2178
2180 presult.lpdead_items, vmbuffer,
2181 &old_vmbits);
2182
2185
2186 /* Set the visibility map and page visibility hint */
2188
2191
2192 /* Nothing to do */
2195
2196 /*
2197 * It should never be the case that the visibility map page is set while
2198 * the page-level bit is clear (and if so, we cleared it above), but the
2199 * reverse is allowed (if checksums are not enabled). Regardless, set both
2200 * bits so that we get back in sync.
2201 *
2202 * The heap buffer must be marked dirty before adding it to the WAL chain
2203 * when setting the VM. We don't worry about unnecessarily dirtying the
2204 * heap buffer if PD_ALL_VISIBLE is already set, though. It is extremely
2205 * rare to have a clean heap buffer with PD_ALL_VISIBLE already set and
2206 * the VM bits clear, so there is no point in optimizing it.
2207 */
2208 PageSetAllVisible(page);
2210
2211 /*
2212 * If the page is being set all-frozen, we pass InvalidTransactionId as
2213 * the cutoff_xid, since a snapshot conflict horizon sufficient to make
2214 * everything safe for REDO was logged when the page's tuples were frozen.
2215 */
2218
2220 InvalidXLogRecPtr,
2221 vmbuffer, presult.vm_conflict_horizon,
2222 new_vmbits);
2223
2224 /*
2225 * If the page wasn't already set all-visible and/or all-frozen in the VM,
2226 * count it as newly set for logging.
2227 */
2229 {
2230 vacrel->vm_new_visible_pages++;
2232 {
2233 vacrel->vm_new_visible_frozen_pages++;
2235 }
2236 }
2238 presult.all_frozen)
2239 {
2240 vacrel->vm_new_frozen_pages++;
2242 }
2243
2245}
2246
2247/*
2248 * lazy_scan_noprune() -- lazy_scan_prune() without pruning or freezing
2249 *
2250 * Caller need only hold a pin and share lock on the buffer, unlike
2251 * lazy_scan_prune, which requires a full cleanup lock. While pruning isn't
2252 * performed here, it's quite possible that an earlier opportunistic pruning
2253 * operation left LP_DEAD items behind. We'll at least collect any such items
2254 * in dead_items for removal from indexes.
2255 *
2256 * For aggressive VACUUM callers, we may return false to indicate that a full
2257 * cleanup lock is required for processing by lazy_scan_prune. This is only
2258 * necessary when the aggressive VACUUM needs to freeze some tuple XIDs from
2259 * one or more tuples on the page. We always return true for non-aggressive
2260 * callers.
2261 *
2262 * If this function returns true, *has_lpdead_items gets set to true or false
2263 * depending on whether, upon return from this function, any LP_DEAD items are
2264 * present on the page. If this function returns false, *has_lpdead_items
2265 * is not updated.
2266 */
2267static bool
2270 BlockNumber blkno,
2271 Page page,
2273{
2274 OffsetNumber offnum,
2275 maxoff;
2276 int lpdead_items,
2277 live_tuples,
2278 recently_dead_tuples,
2279 missed_dead_tuples;
2280 bool hastup;
2285
2287
2288 hastup = false; /* for now */
2289
2290 lpdead_items = 0;
2291 live_tuples = 0;
2292 recently_dead_tuples = 0;
2293 missed_dead_tuples = 0;
2294
2295 maxoff = PageGetMaxOffsetNumber(page);
2297 offnum <= maxoff;
2298 offnum = OffsetNumberNext(offnum))
2299 {
2300 ItemId itemid;
2301 HeapTupleData tuple;
2302
2303 vacrel->offnum = offnum;
2304 itemid = PageGetItemId(page, offnum);
2305
2307 continue;
2308
2310 {
2311 hastup = true;
2312 continue;
2313 }
2314
2316 {
2317 /*
2318 * Deliberately don't set hastup=true here. See same point in
2319 * lazy_scan_prune for an explanation.
2320 */
2321 deadoffsets[lpdead_items++] = offnum;
2322 continue;
2323 }
2324
2325 hastup = true; /* page prevents rel truncation */
2328 &NoFreezePageRelfrozenXid,
2329 &NoFreezePageRelminMxid))
2330 {
2331 /* Tuple with XID < FreezeLimit (or MXID < MultiXactCutoff) */
2333 {
2334 /*
2335 * Aggressive VACUUMs must always be able to advance rel's
2336 * relfrozenxid to a value >= FreezeLimit (and be able to
2337 * advance rel's relminmxid to a value >= MultiXactCutoff).
2338 * The ongoing aggressive VACUUM won't be able to do that
2339 * unless it can freeze an XID (or MXID) from this tuple now.
2340 *
2341 * The only safe option is to have caller perform processing
2342 * of this page using lazy_scan_prune. Caller might have to
2343 * wait a while for a cleanup lock, but it can't be helped.
2344 */
2346 return false;
2347 }
2348
2349 /*
2350 * Non-aggressive VACUUMs are under no obligation to advance
2351 * relfrozenxid (even by one XID). We can be much laxer here.
2352 *
2353 * Currently we always just accept an older final relfrozenxid
2354 * and/or relminmxid value. We never make caller wait or work a
2355 * little harder, even when it likely makes sense to do so.
2356 */
2357 }
2358
2363
2365 buf))
2366 {
2369
2370 /*
2371 * Count both cases as live, just like lazy_scan_prune
2372 */
2373 live_tuples++;
2374
2375 break;
2377
2378 /*
2379 * There is some useful work for pruning to do, that won't be
2380 * done due to failure to get a cleanup lock.
2381 */
2382 missed_dead_tuples++;
2383 break;
2385
2386 /*
2387 * Count in recently_dead_tuples, just like lazy_scan_prune
2388 */
2389 recently_dead_tuples++;
2390 break;
2392
2393 /*
2394 * Do not count these rows as live, just like lazy_scan_prune
2395 */
2396 break;
2397 default:
2399 break;
2400 }
2401 }
2402
2404
2405 /*
2406 * By here we know for sure that caller can put off freezing and pruning
2407 * this particular page until the next VACUUM. Remember its details now.
2408 * (lazy_scan_prune expects a clean slate, so we have to do this last.)
2409 */
2410 vacrel->NewRelfrozenXid = NoFreezePageRelfrozenXid;
2411 vacrel->NewRelminMxid = NoFreezePageRelminMxid;
2412
2413 /* Save any LP_DEAD items found on the page in dead_items */
2415 {
2416 /* Using one-pass strategy (since table has no indexes) */
2417 if (lpdead_items > 0)
2418 {
2419 /*
2420 * Perfunctory handling for the corner case where a single pass
2421 * strategy VACUUM cannot get a cleanup lock, and it turns out
2422 * that there is one or more LP_DEAD items: just count the LP_DEAD
2423 * items as missed_dead_tuples instead. (This is a bit dishonest,
2424 * but it beats having to maintain specialized heap vacuuming code
2425 * forever, for vanishingly little benefit.)
2426 */
2427 hastup = true;
2428 missed_dead_tuples += lpdead_items;
2429 }
2430 }
2431 else if (lpdead_items > 0)
2432 {
2433 /*
2434 * Page has LP_DEAD items, and so any references/TIDs that remain in
2435 * indexes will be deleted during index vacuuming (and then marked
2436 * LP_UNUSED in the heap)
2437 */
2438 vacrel->lpdead_item_pages++;
2439
2441
2442 vacrel->lpdead_items += lpdead_items;
2443 }
2444
2445 /*
2446 * Finally, add relevant page-local counts to whole-VACUUM counts
2447 */
2448 vacrel->live_tuples += live_tuples;
2449 vacrel->recently_dead_tuples += recently_dead_tuples;
2450 vacrel->missed_dead_tuples += missed_dead_tuples;
2451 if (missed_dead_tuples > 0)
2452 vacrel->missed_dead_pages++;
2453
2454 /* Can't truncate this page */
2455 if (hastup)
2456 vacrel->nonempty_pages = blkno + 1;
2457
2458 /* Did we find LP_DEAD items? */
2459 *has_lpdead_items = (lpdead_items > 0);
2460
2461 /* Caller won't need to call lazy_scan_prune with same page */
2462 return true;
2463}
2464
2465/*
2466 * Main entry point for index vacuuming and heap vacuuming.
2467 *
2468 * Removes items collected in dead_items from table's indexes, then marks the
2469 * same items LP_UNUSED in the heap. See the comments above lazy_scan_heap
2470 * for full details.
2471 *
2472 * Also empties dead_items, freeing up space for later TIDs.
2473 *
2474 * We may choose to bypass index vacuuming at this point, though only when the
2475 * ongoing VACUUM operation will definitely only have one index scan/round of
2476 * index vacuuming.
2477 */
2478static void
2480{
2482
2483 /* Should not end up here with no indexes */
2486
2488 {
2491 return;
2492 }
2493
2494 /*
2495 * Consider bypassing index vacuuming (and heap vacuuming) entirely.
2496 *
2497 * We currently only do this in cases where the number of LP_DEAD items
2498 * for the entire VACUUM operation is close to zero. This avoids sharp
2499 * discontinuities in the duration and overhead of successive VACUUM
2500 * operations that run against the same table with a fixed workload.
2501 * Ideally, successive VACUUM operations will behave as if there are
2502 * exactly zero LP_DEAD items in cases where there are close to zero.
2503 *
2504 * This is likely to be helpful with a table that is continually affected
2505 * by UPDATEs that can mostly apply the HOT optimization, but occasionally
2506 * have small aberrations that lead to just a few heap pages retaining
2507 * only one or two LP_DEAD items. This is pretty common; even when the
2508 * DBA goes out of their way to make UPDATEs use HOT, it is practically
2509 * impossible to predict whether HOT will be applied in 100% of cases.
2510 * It's far easier to ensure that 99%+ of all UPDATEs against a table use
2511 * HOT through careful tuning.
2512 */
2515 {
2517
2522
2523 /*
2524 * This crossover point at which we'll start to do index vacuuming is
2525 * expressed as a percentage of the total number of heap pages in the
2526 * table that are known to have at least one LP_DEAD item. This is
2527 * much more important than the total number of LP_DEAD items, since
2528 * it's a proxy for the number of heap pages whose visibility map bits
2529 * cannot be set on account of bypassing index and heap vacuuming.
2530 *
2531 * We apply one further precautionary test: the space currently used
2532 * to store the TIDs (TIDs that now all point to LP_DEAD items) must
2533 * not exceed 32MB. This limits the risk that we will bypass index
2534 * vacuuming again and again until eventually there is a VACUUM whose
2535 * dead_items space is not CPU cache resident.
2536 *
2537 * We don't take any special steps to remember the LP_DEAD items (such
2538 * as counting them in our final update to the stats system) when the
2539 * optimization is applied. Though the accounting used in analyze.c's
2540 * acquire_sample_rows() will recognize the same LP_DEAD items as dead
2541 * rows in its own stats report, that's okay. The discrepancy should
2542 * be negligible. If this optimization is ever expanded to cover more
2543 * cases then this may need to be reconsidered.
2544 */
2548 }
2549
2551 {
2552 /*
2553 * There are almost zero TIDs. Behave as if there were precisely
2554 * zero: bypass index vacuuming, but do index cleanup.
2555 *
2556 * We expect that the ongoing VACUUM operation will finish very
2557 * quickly, so there is no point in considering speeding up as a
2558 * failsafe against wraparound failure. (Index cleanup is expected to
2559 * finish very quickly in cases where there were no ambulkdelete()
2560 * calls.)
2561 */
2563 }
2565 {
2566 /*
2567 * We successfully completed a round of index vacuuming. Do related
2568 * heap vacuuming now.
2569 */
2571 }
2572 else
2573 {
2574 /*
2575 * Failsafe case.
2576 *
2577 * We attempted index vacuuming, but didn't finish a full round/full
2578 * index scan. This happens when relfrozenxid or relminmxid is too
2579 * far in the past.
2580 *
2581 * From this point on the VACUUM operation will do no further index
2582 * vacuuming or heap vacuuming. This VACUUM operation won't end up
2583 * back here again.
2584 */
2586 }
2587
2588 /*
2589 * Forget the LP_DEAD items that we just vacuumed (or just decided to not
2590 * vacuum)
2591 */
2593}
2594
2595/*
2596 * lazy_vacuum_all_indexes() -- Main entry for index vacuuming
2597 *
2598 * Returns true in the common case when all indexes were successfully
2599 * vacuumed. Returns false in rare cases where we determined that the ongoing
2600 * VACUUM operation is at risk of taking too long to finish, leading to
2601 * wraparound failure.
2602 */
2603static bool
2605{
2609 PROGRESS_VACUUM_PHASE,
2611 };
2616 };
2619
2623
2624 /* Precheck for XID wraparound emergencies */
2626 {
2627 /* Wraparound emergency -- don't even start an index scan */
2628 return false;
2629 }
2630
2631 /*
2632 * Report that we are now vacuuming indexes and the number of indexes to
2633 * vacuum.
2634 */
2638
2640 {
2642 {
2645
2647 old_live_tuples,
2648 vacrel);
2649
2650 /* Report the number of indexes vacuumed */
2652 idx + 1);
2653
2655 {
2656 /* Wraparound emergency -- end current index scan */
2658 break;
2659 }
2660 }
2661 }
2662 else
2663 {
2664 /* Outsource everything to parallel variant */
2666 vacrel->num_index_scans);
2667
2668 /*
2669 * Do a postcheck to consider applying wraparound failsafe now. Note
2670 * that parallel VACUUM only gets the precheck and this postcheck.
2671 */
2674 }
2675
2676 /*
2677 * We delete all LP_DEAD items from the first heap pass in all indexes on
2678 * each call here (except calls where we choose to do the failsafe). This
2679 * makes the next call to lazy_vacuum_heap_rel() safe (except in the event
2680 * of the failsafe triggering, which prevents the next call from taking
2681 * place).
2682 */
2686
2687 /*
2688 * Increase and report the number of index scans. Also, we reset
2689 * PROGRESS_VACUUM_INDEXES_TOTAL and PROGRESS_VACUUM_INDEXES_PROCESSED.
2690 *
2691 * We deliberately include the case where we started a round of bulk
2692 * deletes that we weren't able to finish due to the failsafe triggering.
2693 */
2694 vacrel->num_index_scans++;
2695 progress_end_val[0] = 0;
2696 progress_end_val[1] = 0;
2699
2701}
2702
2703/*
2704 * Read stream callback for vacuum's third phase (second pass over the heap).
2705 * Gets the next block from the TID store and returns it or InvalidBlockNumber
2706 * if there are no further blocks to vacuum.
2707 *
2708 * NB: Assumed to be safe to use with READ_STREAM_USE_BATCHING.
2709 */
2712 void *callback_private_data,
2713 void *per_buffer_data)
2714{
2715 TidStoreIter *iter = callback_private_data;
2717
2721
2722 /*
2723 * Save the TidStoreIterResult for later, so we can extract the offsets.
2724 * It is safe to copy the result, according to TidStoreIterateNext().
2725 */
2727
2729}
2730
2731/*
2732 * lazy_vacuum_heap_rel() -- second pass over the heap for two pass strategy
2733 *
2734 * This routine marks LP_DEAD items in vacrel->dead_items as LP_UNUSED. Pages
2735 * that never had lazy_scan_prune record LP_DEAD items are not visited at all.
2736 *
2737 * We may also be able to truncate the line pointer array of the heap pages we
2738 * visit. If there is a contiguous group of LP_UNUSED items at the end of the
2739 * array, it can be reclaimed as free space. These LP_UNUSED items usually
2740 * start out as LP_DEAD items recorded by lazy_scan_prune (we set items from
2741 * each page to LP_UNUSED, and then consider if it's possible to truncate the
2742 * page's line pointer array).
2743 *
2744 * Note: the reason for doing this as a second pass is we cannot remove the
2745 * tuples until we've removed their index entries, and we want to process
2746 * index entry removal in batches as large as possible.
2747 */
2748static void
2750{
2751 ReadStream *stream;
2755 TidStoreIter *iter;
2756
2760
2761 /* Report that we are now vacuuming the heap */
2764
2765 /* Update error traceback information */
2769
2771
2772 /*
2773 * Set up the read stream for vacuum's second pass through the heap.
2774 *
2775 * It is safe to use batchmode, as vacuum_reap_lp_read_stream_next() does
2776 * not need to wait for IO and does not perform locking. Once we support
2777 * parallelism it should still be fine, as presumably the holder of locks
2778 * would never be blocked by IO while holding the lock.
2779 */
2781 READ_STREAM_USE_BATCHING,
2782 vacrel->bstrategy,
2783 vacrel->rel,
2784 MAIN_FORKNUM,
2786 iter,
2788
2789 while (true)
2790 {
2791 BlockNumber blkno;
2793 Page page;
2795 Size freespace;
2798
2800
2802
2803 /* The relation is exhausted */
2805 break;
2806
2808
2812
2813 /*
2814 * Pin the visibility map page in case we need to mark the page
2815 * all-visible. In most cases this will be very cheap, because we'll
2816 * already have the correct page pinned anyway.
2817 */
2819
2820 /* We need a non-cleanup exclusive lock to mark dead_items unused */
2823 num_offsets, vmbuffer);
2824
2825 /* Now that we've vacuumed the page, record its available space */
2827 freespace = PageGetHeapFreeSpace(page);
2828
2831 vacuumed_pages++;
2832 }
2833
2834 read_stream_end(stream);
2835 TidStoreEndIterate(iter);
2836
2839 ReleaseBuffer(vmbuffer);
2840
2841 /*
2842 * We set all LP_DEAD items from the first heap pass to LP_UNUSED during
2843 * the second heap pass. No more, no less.
2844 */
2848
2852 vacuumed_pages)));
2853
2854 /* Revert to the previous phase information for error traceback */
2856}
2857
2858/*
2859 * lazy_vacuum_heap_page() -- free page's LP_DEAD items listed in the
2860 * vacrel->dead_items store.
2861 *
2862 * Caller must have an exclusive buffer lock on the buffer (though a full
2863 * cleanup lock is also acceptable). vmbuffer must be valid and already have
2864 * a pin on blkno's visibility map page.
2865 */
2866static void
2869 Buffer vmbuffer)
2870{
2873 int nunused = 0;
2874 TransactionId visibility_cutoff_xid;
2876 bool all_frozen;
2879
2881
2883
2884 /* Update error traceback information */
2886 VACUUM_ERRCB_PHASE_VACUUM_HEAP, blkno,
2887 InvalidOffsetNumber);
2888
2889 /*
2890 * Before marking dead items unused, check whether the page will become
2891 * all-visible once that change is applied. This lets us reap the tuples
2892 * and mark the page all-visible within the same critical section,
2893 * enabling both changes to be emitted in a single WAL record. Since the
2894 * visibility checks may perform I/O and allocate memory, they must be
2895 * done outside the critical section.
2896 */
2898 vacrel->cutoffs.OldestXmin,
2899 deadoffsets, num_offsets,
2900 &all_frozen, &visibility_cutoff_xid,
2901 &vacrel->offnum))
2902 {
2904 if (all_frozen)
2905 {
2908 }
2909
2910 /*
2911 * Take the lock on the vmbuffer before entering a critical section.
2912 * The heap page lock must also be held while updating the VM to
2913 * ensure consistency.
2914 */
2916 }
2917
2918 START_CRIT_SECTION();
2919
2921 {
2922 ItemId itemid;
2924
2926
2928 ItemIdSetUnused(itemid);
2929 unused[nunused++] = toff;
2930 }
2931
2932 Assert(nunused > 0);
2933
2934 /* Attempt to truncate line pointer array now */
2935 PageTruncateLinePointerArray(page);
2936
2938 {
2939 /*
2940 * The page is guaranteed to have had dead line pointers, so we always
2941 * set PD_ALL_VISIBLE.
2942 */
2943 PageSetAllVisible(page);
2944 visibilitymap_set_vmbits(blkno,
2945 vmbuffer, vmflags,
2946 vacrel->rel->rd_locator);
2947 conflict_xid = visibility_cutoff_xid;
2948 }
2949
2950 /*
2951 * Mark buffer dirty before we write WAL.
2952 */
2953 MarkBufferDirty(buffer);
2954
2955 /* XLOG stuff */
2957 {
2960 vmflags,
2961 conflict_xid,
2963 PRUNE_VACUUM_CLEANUP,
2967 unused, nunused);
2968 }
2969
2970 END_CRIT_SECTION();
2971
2973 {
2974 /* Count the newly set VM page for logging */
2976 vacrel->vm_new_visible_pages++;
2977 if (all_frozen)
2978 vacrel->vm_new_visible_frozen_pages++;
2979 }
2980
2981 /* Revert to the previous phase information for error traceback */
2983}
2984
2985/*
2986 * Trigger the failsafe to avoid wraparound failure when vacrel table has a
2987 * relfrozenxid and/or relminmxid that is dangerously far in the past.
2988 * Triggering the failsafe makes the ongoing VACUUM bypass any further index
2989 * vacuuming and heap vacuuming. Truncating the heap is also bypassed.
2990 *
2991 * Any remaining work (work that VACUUM cannot just bypass) is typically sped
2992 * up when the failsafe triggers. VACUUM stops applying any cost-based delay
2993 * that it started out with.
2994 *
2995 * Returns true when failsafe has been triggered.
2996 */
2997static bool
2999{
3000 /* Don't warn more than once per VACUUM */
3002 return true;
3003
3005 {
3009 PROGRESS_VACUUM_MODE
3010 };
3012
3014
3015 /*
3016 * Abandon use of a buffer access strategy to allow use of all of
3017 * shared buffers. We assume the caller who allocated the memory for
3018 * the BufferAccessStrategy will free it.
3019 */
3021
3022 /* Disable index vacuuming, index cleanup, and heap rel truncation */
3026
3027 /* Reset the progress counters and set the failsafe mode */
3029
3031 (errmsg("bypassing nonessential maintenance of table \"%s.%s.%s\" as a failsafe after %d index scans",
3033 vacrel->num_index_scans),
3035 errhint("Consider increasing configuration parameter \"maintenance_work_mem\" or \"autovacuum_work_mem\".\n"
3036 "You might also need to consider other ways for VACUUM to keep up with the allocation of transaction IDs.")));
3037
3038 /* Stop applying cost limits from this point on */
3040 VacuumCostBalance = 0;
3041
3042 return true;
3043 }
3044
3045 return false;
3046}
3047
3048/*
3049 * lazy_cleanup_all_indexes() -- cleanup all indexes of relation.
3050 */
3051static void
3053{
3057 PROGRESS_VACUUM_PHASE,
3059 };
3063 };
3066
3069
3070 /*
3071 * Report that we are now cleaning up indexes and the number of indexes to
3072 * cleanup.
3073 */
3077
3079 {
3081 {
3084
3087 estimated_count, vacrel);
3088
3089 /* Report the number of indexes cleaned up */
3091 idx + 1);
3092 }
3093 }
3094 else
3095 {
3096 /* Outsource everything to parallel variant */
3098 vacrel->num_index_scans,
3099 estimated_count);
3100 }
3101
3102 /* Reset the progress counters */
3104}
3105
3106/*
3107 * lazy_vacuum_one_index() -- vacuum index relation.
3108 *
3109 * Delete all the index tuples containing a TID collected in
3110 * vacrel->dead_items. Also update running statistics. Exact
3111 * details depend on index AM's ambulkdelete routine.
3112 *
3113 * reltuples is the number of heap tuples to be passed to the
3114 * bulkdelete callback. It's always assumed to be estimated.
3115 * See indexam.sgml for more info.
3116 *
3117 * Returns bulk delete stats derived from input stats
3118 */
3122{
3125
3132 ivinfo.num_heap_tuples = reltuples;
3134
3135 /*
3136 * Update error traceback information.
3137 *
3138 * The index name is saved during this phase and restored immediately
3139 * after this phase. See vacuum_error_callback.
3140 */
3146
3147 /* Do bulk deletion */
3149 vacrel->dead_items_info);
3150
3151 /* Revert to the previous phase information for error traceback */
3155
3156 return istat;
3157}
3158
3159/*
3160 * lazy_cleanup_one_index() -- do post-vacuum cleanup for index relation.
3161 *
3162 * Calls index AM's amvacuumcleanup routine. reltuples is the number
3163 * of heap tuples and estimated_count is true if reltuples is an
3164 * estimated value. See indexam.sgml for more info.
3165 *
3166 * Returns bulk delete stats derived from input stats
3167 */
3170 double reltuples, bool estimated_count,
3172{
3175
3180 ivinfo.estimated_count = estimated_count;
3182
3183 ivinfo.num_heap_tuples = reltuples;
3185
3186 /*
3187 * Update error traceback information.
3188 *
3189 * The index name is saved during this phase and restored immediately
3190 * after this phase. See vacuum_error_callback.
3191 */
3197
3199
3200 /* Revert to the previous phase information for error traceback */
3204
3205 return istat;
3206}
3207
3208/*
3209 * should_attempt_truncation - should we attempt to truncate the heap?
3210 *
3211 * Don't even think about it unless we have a shot at releasing a goodly
3212 * number of pages. Otherwise, the time taken isn't worth it, mainly because
3213 * an AccessExclusive lock must be replayed on any hot standby, where it can
3214 * be particularly disruptive.
3215 *
3216 * Also don't attempt it if wraparound failsafe is in effect. The entire
3217 * system might be refusing to allocate new XIDs at this point. The system
3218 * definitely won't return to normal unless and until VACUUM actually advances
3219 * the oldest relfrozenxid -- which hasn't happened for target rel just yet.
3220 * If lazy_truncate_heap attempted to acquire an AccessExclusiveLock to
3221 * truncate the table under these circumstances, an XID exhaustion error might
3222 * make it impossible for VACUUM to fix the underlying XID exhaustion problem.
3223 * There is very little chance of truncation working out when the failsafe is
3224 * in effect in any case. lazy_scan_prune makes the optimistic assumption
3225 * that any LP_DEAD items it encounters will always be LP_UNUSED by the time
3226 * we're called.
3227 */
3228static bool
3230{
3232
3234 return false;
3235
3240 return true;
3241
3242 return false;
3243}
3244
3245/*
3246 * lazy_truncate_heap - try to truncate off any empty pages at the end
3247 */
3248static void
3250{
3255
3256 /* Report that we are now truncating */
3259
3260 /* Update error traceback information one last time */
3263
3264 /*
3265 * Loop until no more truncating can be done.
3266 */
3267 do
3268 {
3269 /*
3270 * We need full exclusive lock on the relation in order to do
3271 * truncation. If we can't get it, give up rather than waiting --- we
3272 * don't want to block other backends, and we don't want to deadlock
3273 * (which is quite possible considering we already hold a lower-grade
3274 * lock).
3275 */
3277 lock_retry = 0;
3278 while (true)
3279 {
3281 break;
3282
3283 /*
3284 * Check for interrupts while trying to (re-)acquire the exclusive
3285 * lock.
3286 */
3287 CHECK_FOR_INTERRUPTS();
3288
3291 {
3292 /*
3293 * We failed to establish the lock in the specified number of
3294 * retries. This means we give up truncating.
3295 */
3299 return;
3300 }
3301
3305 WAIT_EVENT_VACUUM_TRUNCATE);
3307 }
3308
3309 /*
3310 * Now that we have exclusive lock, look to see if the rel has grown
3311 * whilst we were vacuuming with non-exclusive lock. If so, give up;
3312 * the newly added pages presumably contain non-deletable tuples.
3313 */
3316 {
3317 /*
3318 * Note: we intentionally don't update vacrel->rel_pages with the
3319 * new rel size here. If we did, it would amount to assuming that
3320 * the new pages are empty, which is unlikely. Leaving the numbers
3321 * alone amounts to assuming that the new pages have the same
3322 * tuple density as existing ones, which is less unlikely.
3323 */
3325 return;
3326 }
3327
3328 /*
3329 * Scan backwards from the end to verify that the end pages actually
3330 * contain no tuples. This is *necessary*, not optional, because
3331 * other backends could have added tuples to these pages whilst we
3332 * were vacuuming.
3333 */
3336
3338 {
3339 /* can't do anything after all */
3341 return;
3342 }
3343
3344 /*
3345 * Okay to truncate.
3346 */
3348
3349 /*
3350 * We can release the exclusive lock as soon as we have truncated.
3351 * Other backends can't safely access the relation until they have
3352 * processed the smgr invalidation that smgrtruncate sent out ... but
3353 * that should happen as part of standard invalidation processing once
3354 * they acquire lock on the relation.
3355 */
3357
3358 /*
3359 * Update statistics. Here, it *is* correct to adjust rel_pages
3360 * without also touching reltuples, since the tuple count wasn't
3361 * changed by the truncation.
3362 */
3365
3372}
3373
3374/*
3375 * Rescan end pages to verify that they are (still) empty of tuples.
3376 *
3377 * Returns number of nondeletable pages (last nonempty page + 1).
3378 */
3381{
3383 "prefetch size must be power of 2");
3384
3385 BlockNumber blkno;
3387 instr_time starttime;
3388
3389 /* Initialize the starttime if we check for conflicting lock requests */
3390 INSTR_TIME_SET_CURRENT(starttime);
3391
3392 /*
3393 * Start checking blocks at what we believe relation end to be and move
3394 * backwards. (Strange coding of loop control is needed because blkno is
3395 * unsigned.) To make the scan faster, we prefetch a few blocks at a time
3396 * in forward direction, so that OS-level readahead can kick in.
3397 */
3398 blkno = vacrel->rel_pages;
3401 {
3403 Page page;
3404 OffsetNumber offnum,
3405 maxoff;
3406 bool hastup;
3407
3408 /*
3409 * Check if another process requests a lock on our relation. We are
3410 * holding an AccessExclusiveLock here, so they will be waiting. We
3411 * only do this once per VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL, and we
3412 * only check if that interval has elapsed once every 32 blocks to
3413 * keep the number of system calls and actual shared lock table
3414 * lookups to a minimum.
3415 */
3416 if ((blkno % 32) == 0)
3417 {
3420
3425 >= VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL)
3426 {
3428 {
3432
3434 return blkno;
3435 }
3436 starttime = currenttime;
3437 }
3438 }
3439
3440 /*
3441 * We don't insert a vacuum delay point here, because we have an
3442 * exclusive lock on the table which we want to hold for as short a
3443 * time as possible. We still need to check for interrupts however.
3444 */
3445 CHECK_FOR_INTERRUPTS();
3446
3447 blkno--;
3448
3449 /* If we haven't prefetched this lot yet, do so now. */
3451 {
3454
3457 {
3459 CHECK_FOR_INTERRUPTS();
3460 }
3462 }
3463
3465 vacrel->bstrategy);
3466
3467 /* In this phase we only need shared access to the buffer */
3469
3471
3473 {
3475 continue;
3476 }
3477
3478 hastup = false;
3479 maxoff = PageGetMaxOffsetNumber(page);
3481 offnum <= maxoff;
3482 offnum = OffsetNumberNext(offnum))
3483 {
3484 ItemId itemid;
3485
3486 itemid = PageGetItemId(page, offnum);
3487
3488 /*
3489 * Note: any non-unused item should be taken as a reason to keep
3490 * this page. Even an LP_DEAD item makes truncation unsafe, since
3491 * we must not have cleaned out its index entries.
3492 */
3494 {
3495 hastup = true;
3496 break; /* can stop scanning */
3497 }
3498 } /* scan along page */
3499
3501
3502 /* Done scanning if we found a tuple here */
3503 if (hastup)
3504 return blkno + 1;
3505 }
3506
3507 /*
3508 * If we fall out of the loop, all the previously-thought-to-be-empty
3509 * pages still are; we need not bother to look at the last known-nonempty
3510 * page.
3511 */
3513}
3514
3515/*
3516 * Allocate dead_items and dead_items_info (either using palloc, or in dynamic
3517 * shared memory). Sets both in vacrel for caller.
3518 *
3519 * Also handles parallel initialization as part of allocating dead_items in
3520 * DSM when required.
3521 */
3522static void
3524{
3525 VacDeadItemsInfo *dead_items_info;
3527 autovacuum_work_mem != -1 ?
3529
3530 /*
3531 * Initialize state for a parallel vacuum. As of now, only one worker can
3532 * be used for an index, so we invoke parallelism only if there are at
3533 * least two indexes on a table.
3534 */
3536 {
3537 /*
3538 * Since parallel workers cannot access data in temporary tables, we
3539 * can't perform parallel vacuum on them.
3540 */
3542 {
3543 /*
3544 * Give warning only if the user explicitly tries to perform a
3545 * parallel vacuum on the temporary table.
3546 */
3547 if (nworkers > 0)
3549 (errmsg("disabling parallel option of vacuum on \"%s\" --- cannot vacuum temporary tables in parallel",
3550 vacrel->relname)));
3551 }
3552 else
3554 vacrel->nindexes, nworkers,
3555 vac_work_mem,
3557 vacrel->bstrategy);
3558
3559 /*
3560 * If parallel mode started, dead_items and dead_items_info spaces are
3561 * allocated in DSM.
3562 */
3564 {
3566 &vacrel->dead_items_info);
3567 return;
3568 }
3569 }
3570
3571 /*
3572 * Serial VACUUM case. Allocate both dead_items and dead_items_info
3573 * locally.
3574 */
3575
3578 dead_items_info->num_items = 0;
3579 vacrel->dead_items_info = dead_items_info;
3580
3582}
3583
3584/*
3585 * Add the given block number and offset numbers to dead_items.
3586 */
3587static void
3590{
3594 };
3596
3599
3600 /* update the progress information */
3604}
3605
3606/*
3607 * Forget all collected dead items.
3608 */
3609static void
3611{
3612 /* Update statistics for dead items */
3613 vacrel->num_dead_items_resets++;
3615
3617 {
3620 &vacrel->dead_items_info);
3621 return;
3622 }
3623
3624 /* Recreate the tidstore with the same max_bytes limitation */
3627
3628 /* Reset the counter */
3629 vacrel->dead_items_info->num_items = 0;
3630}
3631
3632/*
3633 * Perform cleanup for resources allocated in dead_items_alloc
3634 */
3635static void
3637{
3639 {
3640 /* Don't bother with pfree here */
3641 return;
3642 }
3643
3644 /* End parallel mode */
3647}
3648
3649#ifdef USE_ASSERT_CHECKING
3650
3651/*
3652 * Wrapper for heap_page_would_be_all_visible() which can be used for callers
3653 * that expect no LP_DEAD on the page. Currently assert-only, but there is no
3654 * reason not to use it outside of asserts.
3655 */
3656static bool
3658 TransactionId OldestXmin,
3659 bool *all_frozen,
3660 TransactionId *visibility_cutoff_xid,
3662{
3663
3665 OldestXmin,
3666 NULL, 0,
3667 all_frozen,
3668 visibility_cutoff_xid,
3669 logging_offnum);
3670}
3671#endif
3672
3673/*
3674 * Check whether the heap page in buf is all-visible except for the dead
3675 * tuples referenced in the deadoffsets array.
3676 *
3677 * Vacuum uses this to check if a page would become all-visible after reaping
3678 * known dead tuples. This function does not remove the dead items.
3679 *
3680 * This cannot be called in a critical section, as the visibility checks may
3681 * perform IO and allocate memory.
3682 *
3683 * Returns true if the page is all-visible other than the provided
3684 * deadoffsets and false otherwise.
3685 *
3686 * OldestXmin is used to determine visibility.
3687 *
3688 * Output parameters:
3689 *
3690 * - *all_frozen: true if every tuple on the page is frozen
3691 * - *visibility_cutoff_xid: newest xmin; valid only if page is all-visible
3692 * - *logging_offnum: OffsetNumber of current tuple being processed;
3693 * used by vacuum's error callback system.
3694 *
3695 * Callers looking to verify that the page is already all-visible can call
3696 * heap_page_is_all_visible().
3697 *
3698 * This logic is closely related to heap_prune_record_unchanged_lp_normal().
3699 * If you modify this function, ensure consistency with that code. An
3700 * assertion cross-checks that both remain in agreement. Do not introduce new
3701 * side-effects.
3702 */
3703static bool
3705 TransactionId OldestXmin,
3706 OffsetNumber *deadoffsets,
3708 bool *all_frozen,
3709 TransactionId *visibility_cutoff_xid,
3711{
3714 OffsetNumber offnum,
3715 maxoff;
3716 bool all_visible = true;
3718
3719 *visibility_cutoff_xid = InvalidTransactionId;
3720 *all_frozen = true;
3721
3723
3724#ifdef USE_ASSERT_CHECKING
3725 /* Confirm input deadoffsets[] is strictly sorted */
3727 {
3730 }
3731#endif
3732
3733 maxoff = PageGetMaxOffsetNumber(page);
3735 offnum <= maxoff && all_visible;
3736 offnum = OffsetNumberNext(offnum))
3737 {
3738 ItemId itemid;
3739 HeapTupleData tuple;
3740
3741 /*
3742 * Set the offset number so that we can display it along with any
3743 * error that occurred while processing this tuple.
3744 */
3745 *logging_offnum = offnum;
3746 itemid = PageGetItemId(page, offnum);
3747
3748 /* Unused or redirect line pointers are of no interest */
3750 continue;
3751
3753
3754 /*
3755 * Dead line pointers can have index pointers pointing to them. So
3756 * they can't be treated as visible
3757 */
3759 {
3760 if (!deadoffsets ||
3762 deadoffsets[matched_dead_count] != offnum)
3763 {
3764 *all_frozen = all_visible = false;
3765 break;
3766 }
3767 matched_dead_count++;
3768 continue;
3769 }
3770
3772
3776
3777 /* Visibility checks may do IO or allocate memory */
3780 {
3782 {
3783 TransactionId xmin;
3784
3785 /* Check comments in lazy_scan_prune. */
3787 {
3788 all_visible = false;
3789 *all_frozen = false;
3790 break;
3791 }
3792
3793 /*
3794 * The inserter definitely committed. But is it old enough
3795 * that everyone sees it as committed?
3796 */
3799 {
3800 all_visible = false;
3801 *all_frozen = false;
3802 break;
3803 }
3804
3805 /* Track newest xmin on page. */
3807 TransactionIdIsNormal(xmin))
3808 *visibility_cutoff_xid = xmin;
3809
3810 /* Check whether this tuple is already frozen or not */
3811 if (all_visible && *all_frozen &&
3813 *all_frozen = false;
3814 }
3815 break;
3816
3821 {
3822 all_visible = false;
3823 *all_frozen = false;
3824 break;
3825 }
3826 default:
3828 break;
3829 }
3830 } /* scan along page */
3831
3832 /* Clear the offset information once we have processed the given page. */
3834
3835 return all_visible;
3836}
3837
3838/*
3839 * Update index statistics in pg_class if the statistics are accurate.
3840 */
3841static void
3843{
3847
3849
3851 {
3854
3856 continue;
3857
3858 /* Update index statistics */
3860 istat->num_pages,
3861 istat->num_index_tuples,
3862 0, 0,
3863 false,
3864 InvalidTransactionId,
3865 InvalidMultiXactId,
3867 }
3868}
3869
3870/*
3871 * Error context callback for errors occurring during vacuum. The error
3872 * context messages for index phases should match the messages set in parallel
3873 * vacuum. If you change this function for those phases, change
3874 * parallel_vacuum_error_callback() as well.
3875 */
3876static void
3878{
3880
3882 {
3885 {
3889 else
3892 }
3893 else
3896 break;
3897
3900 {
3904 else
3907 }
3908 else
3911 break;
3912
3916 break;
3917
3921 break;
3922
3927 break;
3928
3930 default:
3931 return; /* do nothing; the errinfo may not be
3932 * initialized */
3933 }
3934}
3935
3936/*
3937 * Updates the information required for vacuum error callback. This also saves
3938 * the current information which can be later restored via restore_vacuum_error_info.
3939 */
3940static void
3943{
3945 {
3949 }
3950
3951 vacrel->blkno = blkno;
3952 vacrel->offnum = offnum;
3953 vacrel->phase = phase;
3954}
3955
3956/*
3957 * Restores the vacuum information saved via a prior call to update_vacuum_error_info.
3958 */
3959static void
3962{
3966}
void TimestampDifference(TimestampTz start_time, TimestampTz stop_time, long *secs, int *microsecs)
Definition timestamp.c:1721
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
Definition timestamp.c:1781
void pgstat_progress_start_command(ProgressCommandType cmdtype, Oid relid)
Definition backend_progress.c:27
void pgstat_progress_update_param(int index, int64 val)
Definition backend_progress.c:48
void pgstat_progress_update_multi_param(int nparam, const int *index, const int64 *val)
Definition backend_progress.c:121
PrefetchBufferResult PrefetchBuffer(Relation reln, ForkNumber forkNum, BlockNumber blockNum)
Definition bufmgr.c:772
bool BufferIsLockedByMeInMode(Buffer buffer, BufferLockMode mode)
Definition bufmgr.c:2997
Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy)
Definition bufmgr.c:911
bool ConditionalLockBufferForCleanup(Buffer buffer)
Definition bufmgr.c:6690
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition bufpage.h:243
static void * PageGetItem(PageData *page, const ItemIdData *itemId)
Definition bufpage.h:353
static OffsetNumber PageGetMaxOffsetNumber(const PageData *page)
Definition bufpage.h:371
void FreeSpaceMapVacuumRange(Relation rel, BlockNumber start, BlockNumber end)
Definition freespace.c:377
Size GetRecordedFreeSpace(Relation rel, BlockNumber heapBlk)
Definition freespace.c:244
void RecordPageWithFreeSpace(Relation rel, BlockNumber heapBlk, Size spaceAvail)
Definition freespace.c:194
bool heap_tuple_needs_eventual_freeze(HeapTupleHeader tuple)
Definition heapam.c:7899
bool heap_tuple_should_freeze(HeapTupleHeader tuple, const struct VacuumCutoffs *cutoffs, TransactionId *NoFreezePageRelfrozenXid, MultiXactId *NoFreezePageRelminMxid)
Definition heapam.c:7954
HTSV_Result HeapTupleSatisfiesVacuum(HeapTuple htup, TransactionId OldestXmin, Buffer buffer)
Definition heapam_visibility.c:1042
static TransactionId HeapTupleHeaderGetXmin(const HeapTupleHeaderData *tup)
Definition htup_details.h:324
static bool HeapTupleHeaderXminCommitted(const HeapTupleHeaderData *tup)
Definition htup_details.h:337
void WalUsageAccumDiff(WalUsage *dst, const WalUsage *add, const WalUsage *sub)
Definition instrument.c:285
void BufferUsageAccumDiff(BufferUsage *dst, const BufferUsage *add, const BufferUsage *sub)
Definition instrument.c:245
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
Definition itemptr.h:135
int WaitLatch(Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
Definition latch.c:172
bool ConditionalLockRelation(Relation relation, LOCKMODE lockmode)
Definition lmgr.c:278
bool LockHasWaitersRelation(Relation relation, LOCKMODE lockmode)
Definition lmgr.c:367
bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2)
Definition multixact.c:2765
bool MultiXactIdPrecedesOrEquals(MultiXactId multi1, MultiXactId multi2)
Definition multixact.c:2779
void pgstat_report_vacuum(Relation rel, PgStat_Counter livetuples, PgStat_Counter deadtuples, TimestampTz starttime)
Definition pgstat_relation.c:210
#define PROGRESS_VACUUM_PHASE_FINAL_CLEANUP
Definition progress.h:41
#define PROGRESS_VACUUM_STARTED_BY_AUTOVACUUM
Definition progress.h:50
#define PROGRESS_VACUUM_STARTED_BY_AUTOVACUUM_WRAPAROUND
Definition progress.h:51
#define PROGRESS_VACUUM_MAX_DEAD_TUPLE_BYTES
Definition progress.h:26
#define PROGRESS_VACUUM_PHASE_INDEX_CLEANUP
Definition progress.h:39
#define PROGRESS_VACUUM_PHASE_VACUUM_INDEX
Definition progress.h:37
#define PROGRESS_VACUUM_HEAP_BLKS_VACUUMED
Definition progress.h:24
void heap_page_prune_and_freeze(PruneFreezeParams *params, PruneFreezeResult *presult, OffsetNumber *off_loc, TransactionId *new_relfrozen_xid, MultiXactId *new_relmin_mxid)
Definition pruneheap.c:819
void log_heap_prune_and_freeze(Relation relation, Buffer buffer, Buffer vmbuffer, uint8 vmflags, TransactionId conflict_xid, bool cleanup_lock, PruneReason reason, HeapTupleFreeze *frozen, int nfrozen, OffsetNumber *redirected, int nredirected, OffsetNumber *dead, int ndead, OffsetNumber *unused, int nunused)
Definition pruneheap.c:2167
Buffer read_stream_next_buffer(ReadStream *stream, void **per_buffer_data)
Definition read_stream.c:791
ReadStream * read_stream_begin_relation(int flags, BufferAccessStrategy strategy, Relation rel, ForkNumber forknum, ReadStreamBlockNumberCB callback, void *callback_private_data, size_t per_buffer_data_size)
Definition read_stream.c:737
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition stringinfo.c:145
void appendStringInfoString(StringInfo str, const char *s)
Definition stringinfo.c:230
Definition freelist.c:65
Definition instrument.h:25
Definition elog.h:296
Definition procarray.c:170
Definition htup.h:63
Definition htup_details.h:154
Definition genam.h:82
Definition genam.h:51
Definition itemid.h:26
Definition vacuumlazy.c:250
BlockNumber next_eager_scan_region_start
Definition vacuumlazy.c:369
bool next_unskippable_eager_scanned
Definition vacuumlazy.c:354
BlockNumber eager_scan_remaining_fails
Definition vacuumlazy.c:401
bool consider_bypass_optimization
Definition vacuumlazy.c:265
BlockNumber eager_scan_remaining_successes
Definition vacuumlazy.c:380
BlockNumber eager_scan_max_fails_per_region
Definition vacuumlazy.c:391
BlockNumber vm_new_visible_frozen_pages
Definition vacuumlazy.c:324
Definition vacuumlazy.c:407
Definition pg_rusage.h:23
Definition vacuumparallel.c:163
int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM]
Definition backend_status.h:170
Definition heapam.h:237
Definition heapam.h:278
Definition read_stream.c:93
Definition rel.h:56
Definition stringinfo.h:47
Definition tidstore.h:28
Definition tidstore.c:136
Definition tidstore.c:115
Definition vacuum.h:298
Definition vacuum.h:259
Definition vacuum.h:218
double max_eager_freeze_failure_rate
Definition vacuum.h:244
Definition instrument.h:52
Definition instr_time.h:70
TidStoreIterResult * TidStoreIterateNext(TidStoreIter *iter)
Definition tidstore.c:493
TidStore * TidStoreCreateLocal(size_t max_bytes, bool insert_only)
Definition tidstore.c:162
int TidStoreGetBlockOffsets(TidStoreIterResult *result, OffsetNumber *offsets, int max_offsets)
Definition tidstore.c:566
void TidStoreSetBlockOffsets(TidStore *ts, BlockNumber blkno, OffsetNumber *offsets, int num_offsets)
Definition tidstore.c:345
static bool TransactionIdFollows(TransactionId id1, TransactionId id2)
Definition transam.h:297
static bool TransactionIdPrecedesOrEquals(TransactionId id1, TransactionId id2)
Definition transam.h:282
static bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition transam.h:263
void vac_open_indexes(Relation relation, LOCKMODE lockmode, int *nindexes, Relation **Irel)
Definition vacuum.c:2362
IndexBulkDeleteResult * vac_cleanup_one_index(IndexVacuumInfo *ivinfo, IndexBulkDeleteResult *istat)
Definition vacuum.c:2654
void vac_close_indexes(int nindexes, Relation *Irel, LOCKMODE lockmode)
Definition vacuum.c:2405
bool vacuum_xid_failsafe_check(const struct VacuumCutoffs *cutoffs)
Definition vacuum.c:1268
double vac_estimate_reltuples(Relation relation, BlockNumber total_pages, BlockNumber scanned_pages, double scanned_tuples)
Definition vacuum.c:1330
void vac_update_relstats(Relation relation, BlockNumber num_pages, double num_tuples, BlockNumber num_all_visible_pages, BlockNumber num_all_frozen_pages, bool hasindex, TransactionId frozenxid, MultiXactId minmulti, bool *frozenxid_updated, bool *minmulti_updated, bool in_outer_xact)
Definition vacuum.c:1426
bool vacuum_get_cutoffs(Relation rel, const VacuumParams params, struct VacuumCutoffs *cutoffs)
Definition vacuum.c:1100
IndexBulkDeleteResult * vac_bulkdel_one_index(IndexVacuumInfo *ivinfo, IndexBulkDeleteResult *istat, TidStore *dead_items, VacDeadItemsInfo *dead_items_info)
Definition vacuum.c:2633
static int lazy_scan_prune(LVRelState *vacrel, Buffer buf, BlockNumber blkno, Page page, Buffer vmbuffer, bool *has_lpdead_items, bool *vm_page_frozen)
Definition vacuumlazy.c:2056
static void identify_and_fix_vm_corruption(Relation rel, Buffer heap_buffer, BlockNumber heap_blk, Page heap_page, int nlpdead_items, Buffer vmbuffer, uint8 *vmbits)
Definition vacuumlazy.c:1980
static void update_relstats_all_indexes(LVRelState *vacrel)
Definition vacuumlazy.c:3843
static void dead_items_add(LVRelState *vacrel, BlockNumber blkno, OffsetNumber *offsets, int num_offsets)
Definition vacuumlazy.c:3589
void heap_vacuum_rel(Relation rel, const VacuumParams params, BufferAccessStrategy bstrategy)
Definition vacuumlazy.c:624
static BlockNumber heap_vac_scan_next_block(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
Definition vacuumlazy.c:1619
static void heap_vacuum_eager_scan_setup(LVRelState *vacrel, const VacuumParams params)
Definition vacuumlazy.c:497
#define VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL
Definition vacuumlazy.c:177
static bool heap_page_would_be_all_visible(Relation rel, Buffer buf, TransactionId OldestXmin, OffsetNumber *deadoffsets, int ndeadoffsets, bool *all_frozen, TransactionId *visibility_cutoff_xid, OffsetNumber *logging_offnum)
Definition vacuumlazy.c:3705
static void lazy_cleanup_all_indexes(LVRelState *vacrel)
Definition vacuumlazy.c:3053
static bool lazy_scan_noprune(LVRelState *vacrel, Buffer buf, BlockNumber blkno, Page page, bool *has_lpdead_items)
Definition vacuumlazy.c:2269
static BlockNumber vacuum_reap_lp_read_stream_next(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
Definition vacuumlazy.c:2712
static bool should_attempt_truncation(LVRelState *vacrel)
Definition vacuumlazy.c:3230
static bool lazy_scan_new_or_empty(LVRelState *vacrel, Buffer buf, BlockNumber blkno, Page page, bool sharelock, Buffer vmbuffer)
Definition vacuumlazy.c:1848
static void restore_vacuum_error_info(LVRelState *vacrel, const LVSavedErrInfo *saved_vacrel)
Definition vacuumlazy.c:3961
static IndexBulkDeleteResult * lazy_vacuum_one_index(Relation indrel, IndexBulkDeleteResult *istat, double reltuples, LVRelState *vacrel)
Definition vacuumlazy.c:3121
static void find_next_unskippable_block(LVRelState *vacrel, bool *skipsallvis)
Definition vacuumlazy.c:1719
static bool lazy_check_wraparound_failsafe(LVRelState *vacrel)
Definition vacuumlazy.c:2999
static IndexBulkDeleteResult * lazy_cleanup_one_index(Relation indrel, IndexBulkDeleteResult *istat, double reltuples, bool estimated_count, LVRelState *vacrel)
Definition vacuumlazy.c:3170
static void lazy_vacuum_heap_page(LVRelState *vacrel, BlockNumber blkno, Buffer buffer, OffsetNumber *deadoffsets, int num_offsets, Buffer vmbuffer)
Definition vacuumlazy.c:2868
static void dead_items_alloc(LVRelState *vacrel, int nworkers)
Definition vacuumlazy.c:3524
static bool lazy_vacuum_all_indexes(LVRelState *vacrel)
Definition vacuumlazy.c:2605
static void update_vacuum_error_info(LVRelState *vacrel, LVSavedErrInfo *saved_vacrel, int phase, BlockNumber blkno, OffsetNumber offnum)
Definition vacuumlazy.c:3942
static BlockNumber count_nondeletable_pages(LVRelState *vacrel, bool *lock_waiter_detected)
Definition vacuumlazy.c:3381
#define VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL
Definition vacuumlazy.c:176
static int cmpOffsetNumbers(const void *a, const void *b)
Definition vacuumlazy.c:1958
static void lazy_vacuum_heap_rel(LVRelState *vacrel)
Definition vacuumlazy.c:2750
TidStore * parallel_vacuum_get_dead_items(ParallelVacuumState *pvs, VacDeadItemsInfo **dead_items_info_p)
Definition vacuumparallel.c:467
ParallelVacuumState * parallel_vacuum_init(Relation rel, Relation *indrels, int nindexes, int nrequested_workers, int vac_work_mem, int elevel, BufferAccessStrategy bstrategy)
Definition vacuumparallel.c:243
void parallel_vacuum_bulkdel_all_indexes(ParallelVacuumState *pvs, long num_table_tuples, int num_index_scans)
Definition vacuumparallel.c:500
void parallel_vacuum_reset_dead_items(ParallelVacuumState *pvs)
Definition vacuumparallel.c:475
void parallel_vacuum_cleanup_all_indexes(ParallelVacuumState *pvs, long num_table_tuples, int num_index_scans, bool estimated_count)
Definition vacuumparallel.c:519
void parallel_vacuum_end(ParallelVacuumState *pvs, IndexBulkDeleteResult **istats)
Definition vacuumparallel.c:436
void visibilitymap_set(Relation rel, BlockNumber heapBlk, Buffer heapBuf, XLogRecPtr recptr, Buffer vmBuf, TransactionId cutoff_xid, uint8 flags)
Definition visibilitymap.c:245
bool visibilitymap_clear(Relation rel, BlockNumber heapBlk, Buffer vmbuf, uint8 flags)
Definition visibilitymap.c:139
void visibilitymap_pin(Relation rel, BlockNumber heapBlk, Buffer *vmbuf)
Definition visibilitymap.c:192
uint8 visibilitymap_get_status(Relation rel, BlockNumber heapBlk, Buffer *vmbuf)
Definition visibilitymap.c:408
void visibilitymap_count(Relation rel, BlockNumber *all_visible, BlockNumber *all_frozen)
Definition visibilitymap.c:456
void visibilitymap_set_vmbits(BlockNumber heapBlk, Buffer vmBuf, uint8 flags, const RelFileLocator rlocator)
Definition visibilitymap.c:344
XLogRecPtr log_newpage_buffer(Buffer buffer, bool page_std)
Definition xloginsert.c:1259
◆ MAX_EAGER_FREEZE_SUCCESS_RATE
| #define MAX_EAGER_FREEZE_SUCCESS_RATE 0.2 |
Definition at line 238 of file vacuumlazy.c.
◆ ParallelVacuumIsActive
Definition at line 218 of file vacuumlazy.c.
◆ PREFETCH_SIZE
| #define PREFETCH_SIZE ((BlockNumber) 32) |
Definition at line 212 of file vacuumlazy.c.
◆ REL_TRUNCATE_FRACTION
| #define REL_TRUNCATE_FRACTION 16 |
Definition at line 167 of file vacuumlazy.c.
◆ REL_TRUNCATE_MINIMUM
| #define REL_TRUNCATE_MINIMUM 1000 |
Definition at line 166 of file vacuumlazy.c.
◆ SKIP_PAGES_THRESHOLD
| #define SKIP_PAGES_THRESHOLD ((BlockNumber) 32) |
Definition at line 206 of file vacuumlazy.c.
◆ VACUUM_FSM_EVERY_PAGES
| #define VACUUM_FSM_EVERY_PAGES ((BlockNumber) (((uint64) 8 * 1024 * 1024 * 1024) / BLCKSZ)) |
Definition at line 199 of file vacuumlazy.c.
◆ VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL
| #define VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL 20 /* ms */ |
Definition at line 176 of file vacuumlazy.c.
◆ VACUUM_TRUNCATE_LOCK_TIMEOUT
| #define VACUUM_TRUNCATE_LOCK_TIMEOUT 5000 /* ms */ |
Definition at line 178 of file vacuumlazy.c.
◆ VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL
| #define VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL 50 /* ms */ |
Definition at line 177 of file vacuumlazy.c.
Typedef Documentation
◆ LVRelState
◆ LVSavedErrInfo
Enumeration Type Documentation
◆ VacErrPhase
| Enumerator | |
|---|---|
| VACUUM_ERRCB_PHASE_UNKNOWN | |
| VACUUM_ERRCB_PHASE_SCAN_HEAP | |
| VACUUM_ERRCB_PHASE_VACUUM_INDEX | |
| VACUUM_ERRCB_PHASE_VACUUM_HEAP | |
| VACUUM_ERRCB_PHASE_INDEX_CLEANUP | |
| VACUUM_ERRCB_PHASE_TRUNCATE | |
Definition at line 221 of file vacuumlazy.c.
222{
229} VacErrPhase;
Function Documentation
◆ cmpOffsetNumbers()
Definition at line 1958 of file vacuumlazy.c.
References a, b, and pg_cmp_u16().
Referenced by lazy_scan_prune().
◆ count_nondeletable_pages()
|
static |
Definition at line 3381 of file vacuumlazy.c.
3382{
3384 "prefetch size must be power of 2");
3385
3386 BlockNumber blkno;
3388 instr_time starttime;
3389
3390 /* Initialize the starttime if we check for conflicting lock requests */
3391 INSTR_TIME_SET_CURRENT(starttime);
3392
3393 /*
3394 * Start checking blocks at what we believe relation end to be and move
3395 * backwards. (Strange coding of loop control is needed because blkno is
3396 * unsigned.) To make the scan faster, we prefetch a few blocks at a time
3397 * in forward direction, so that OS-level readahead can kick in.
3398 */
3399 blkno = vacrel->rel_pages;
3402 {
3404 Page page;
3405 OffsetNumber offnum,
3406 maxoff;
3407 bool hastup;
3408
3409 /*
3410 * Check if another process requests a lock on our relation. We are
3411 * holding an AccessExclusiveLock here, so they will be waiting. We
3412 * only do this once per VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL, and we
3413 * only check if that interval has elapsed once every 32 blocks to
3414 * keep the number of system calls and actual shared lock table
3415 * lookups to a minimum.
3416 */
3417 if ((blkno % 32) == 0)
3418 {
3421
3426 >= VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL)
3427 {
3429 {
3433
3435 return blkno;
3436 }
3437 starttime = currenttime;
3438 }
3439 }
3440
3441 /*
3442 * We don't insert a vacuum delay point here, because we have an
3443 * exclusive lock on the table which we want to hold for as short a
3444 * time as possible. We still need to check for interrupts however.
3445 */
3446 CHECK_FOR_INTERRUPTS();
3447
3448 blkno--;
3449
3450 /* If we haven't prefetched this lot yet, do so now. */
3452 {
3455
3458 {
3460 CHECK_FOR_INTERRUPTS();
3461 }
3463 }
3464
3466 vacrel->bstrategy);
3467
3468 /* In this phase we only need shared access to the buffer */
3470
3472
3474 {
3476 continue;
3477 }
3478
3479 hastup = false;
3480 maxoff = PageGetMaxOffsetNumber(page);
3482 offnum <= maxoff;
3483 offnum = OffsetNumberNext(offnum))
3484 {
3485 ItemId itemid;
3486
3487 itemid = PageGetItemId(page, offnum);
3488
3489 /*
3490 * Note: any non-unused item should be taken as a reason to keep
3491 * this page. Even an LP_DEAD item makes truncation unsafe, since
3492 * we must not have cleaned out its index entries.
3493 */
3495 {
3496 hastup = true;
3497 break; /* can stop scanning */
3498 }
3499 } /* scan along page */
3500
3502
3503 /* Done scanning if we found a tuple here */
3504 if (hastup)
3505 return blkno + 1;
3506 }
3507
3508 /*
3509 * If we fall out of the loop, all the previously-thought-to-be-empty
3510 * pages still are; we need not bother to look at the last known-nonempty
3511 * page.
3512 */
3514}
References AccessExclusiveLock, buf, BUFFER_LOCK_SHARE, BufferGetPage(), CHECK_FOR_INTERRUPTS, DEBUG2, ereport, errmsg(), fb(), FirstOffsetNumber, INFO, INSTR_TIME_GET_MICROSEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, InvalidBlockNumber, ItemIdIsUsed, LockBuffer(), LockHasWaitersRelation(), MAIN_FORKNUM, OffsetNumberNext, PageGetItemId(), PageGetMaxOffsetNumber(), PageIsEmpty(), PageIsNew(), PREFETCH_SIZE, PrefetchBuffer(), RBM_NORMAL, ReadBufferExtended(), StaticAssertDecl, UnlockReleaseBuffer(), and VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL.
Referenced by lazy_truncate_heap().
◆ dead_items_add()
|
static |
Definition at line 3589 of file vacuumlazy.c.
3591{
3595 };
3597
3600
3601 /* update the progress information */
3605}
References fb(), pgstat_progress_update_multi_param(), PROGRESS_VACUUM_DEAD_TUPLE_BYTES, PROGRESS_VACUUM_NUM_DEAD_ITEM_IDS, TidStoreMemoryUsage(), and TidStoreSetBlockOffsets().
Referenced by lazy_scan_noprune(), and lazy_scan_prune().
◆ dead_items_alloc()
|
static |
Definition at line 3524 of file vacuumlazy.c.
3525{
3526 VacDeadItemsInfo *dead_items_info;
3528 autovacuum_work_mem != -1 ?
3530
3531 /*
3532 * Initialize state for a parallel vacuum. As of now, only one worker can
3533 * be used for an index, so we invoke parallelism only if there are at
3534 * least two indexes on a table.
3535 */
3537 {
3538 /*
3539 * Since parallel workers cannot access data in temporary tables, we
3540 * can't perform parallel vacuum on them.
3541 */
3543 {
3544 /*
3545 * Give warning only if the user explicitly tries to perform a
3546 * parallel vacuum on the temporary table.
3547 */
3548 if (nworkers > 0)
3550 (errmsg("disabling parallel option of vacuum on \"%s\" --- cannot vacuum temporary tables in parallel",
3551 vacrel->relname)));
3552 }
3553 else
3555 vacrel->nindexes, nworkers,
3556 vac_work_mem,
3558 vacrel->bstrategy);
3559
3560 /*
3561 * If parallel mode started, dead_items and dead_items_info spaces are
3562 * allocated in DSM.
3563 */
3565 {
3567 &vacrel->dead_items_info);
3568 return;
3569 }
3570 }
3571
3572 /*
3573 * Serial VACUUM case. Allocate both dead_items and dead_items_info
3574 * locally.
3575 */
3576
3579 dead_items_info->num_items = 0;
3580 vacrel->dead_items_info = dead_items_info;
3581
3583}
References AmAutoVacuumWorkerProcess, autovacuum_work_mem, ParallelVacuumState::dead_items, DEBUG2, ereport, errmsg(), fb(), INFO, maintenance_work_mem, VacDeadItemsInfo::max_bytes, VacDeadItemsInfo::num_items, palloc_object, parallel_vacuum_get_dead_items(), parallel_vacuum_init(), ParallelVacuumIsActive, RelationUsesLocalBuffers, TidStoreCreateLocal(), and WARNING.
Referenced by heap_vacuum_rel().
◆ dead_items_cleanup()
|
static |
Definition at line 3637 of file vacuumlazy.c.
3638{
3640 {
3641 /* Don't bother with pfree here */
3642 return;
3643 }
3644
3645 /* End parallel mode */
3648}
References fb(), parallel_vacuum_end(), and ParallelVacuumIsActive.
Referenced by heap_vacuum_rel().
◆ dead_items_reset()
|
static |
Definition at line 3611 of file vacuumlazy.c.
3612{
3613 /* Update statistics for dead items */
3614 vacrel->num_dead_items_resets++;
3616
3618 {
3621 &vacrel->dead_items_info);
3622 return;
3623 }
3624
3625 /* Recreate the tidstore with the same max_bytes limitation */
3628
3629 /* Reset the counter */
3630 vacrel->dead_items_info->num_items = 0;
3631}
References fb(), parallel_vacuum_get_dead_items(), parallel_vacuum_reset_dead_items(), ParallelVacuumIsActive, TidStoreCreateLocal(), TidStoreDestroy(), and TidStoreMemoryUsage().
Referenced by lazy_vacuum().
◆ find_next_unskippable_block()
|
static |
Definition at line 1719 of file vacuumlazy.c.
1720{
1724 bool next_unskippable_eager_scanned = false;
1725
1727
1728 for (;; next_unskippable_block++)
1729 {
1731 next_unskippable_block,
1732 &next_unskippable_vmbuffer);
1733
1734
1735 /*
1736 * At the start of each eager scan region, normal vacuums with eager
1737 * scanning enabled reset the failure counter, allowing vacuum to
1738 * resume eager scanning if it had been suspended in the previous
1739 * region.
1740 */
1742 {
1743 vacrel->eager_scan_remaining_fails =
1744 vacrel->eager_scan_max_fails_per_region;
1746 }
1747
1748 /*
1749 * A block is unskippable if it is not all visible according to the
1750 * visibility map.
1751 */
1753 {
1755 break;
1756 }
1757
1758 /*
1759 * Caller must scan the last page to determine whether it has tuples
1760 * (caller must have the opportunity to set vacrel->nonempty_pages).
1761 * This rule avoids having lazy_truncate_heap() take access-exclusive
1762 * lock on rel to attempt a truncation that fails anyway, just because
1763 * there are tuples on the last page (it is likely that there will be
1764 * tuples on other nearby pages as well, but those can be skipped).
1765 *
1766 * Implement this by always treating the last block as unsafe to skip.
1767 */
1768 if (next_unskippable_block == rel_pages - 1)
1769 break;
1770
1771 /* DISABLE_PAGE_SKIPPING makes all skipping unsafe */
1773 break;
1774
1775 /*
1776 * All-frozen pages cannot contain XIDs < OldestXmin (XIDs that aren't
1777 * already frozen by now), so this page can be skipped.
1778 */
1780 continue;
1781
1782 /*
1783 * Aggressive vacuums cannot skip any all-visible pages that are not
1784 * also all-frozen.
1785 */
1787 break;
1788
1789 /*
1790 * Normal vacuums with eager scanning enabled only skip all-visible
1791 * but not all-frozen pages if they have hit the failure limit for the
1792 * current eager scan region.
1793 */
1795 {
1796 next_unskippable_eager_scanned = true;
1797 break;
1798 }
1799
1800 /*
1801 * All-visible blocks are safe to skip in a normal vacuum. But
1802 * remember that the final range contains such a block for later.
1803 */
1805 }
1806
1807 /* write the local variables back to vacrel */
1808 vacrel->next_unskippable_block = next_unskippable_block;
1809 vacrel->next_unskippable_eager_scanned = next_unskippable_eager_scanned;
1810 vacrel->next_unskippable_vmbuffer = next_unskippable_vmbuffer;
1811}
References Assert, EAGER_SCAN_REGION_SIZE, fb(), VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, and visibilitymap_get_status().
Referenced by heap_vac_scan_next_block().
◆ heap_page_would_be_all_visible()
|
static |
Definition at line 3705 of file vacuumlazy.c.
3712{
3715 OffsetNumber offnum,
3716 maxoff;
3717 bool all_visible = true;
3719
3720 *visibility_cutoff_xid = InvalidTransactionId;
3721 *all_frozen = true;
3722
3724
3725#ifdef USE_ASSERT_CHECKING
3726 /* Confirm input deadoffsets[] is strictly sorted */
3728 {
3731 }
3732#endif
3733
3734 maxoff = PageGetMaxOffsetNumber(page);
3736 offnum <= maxoff && all_visible;
3737 offnum = OffsetNumberNext(offnum))
3738 {
3739 ItemId itemid;
3740 HeapTupleData tuple;
3741
3742 /*
3743 * Set the offset number so that we can display it along with any
3744 * error that occurred while processing this tuple.
3745 */
3746 *logging_offnum = offnum;
3747 itemid = PageGetItemId(page, offnum);
3748
3749 /* Unused or redirect line pointers are of no interest */
3751 continue;
3752
3754
3755 /*
3756 * Dead line pointers can have index pointers pointing to them. So
3757 * they can't be treated as visible
3758 */
3760 {
3761 if (!deadoffsets ||
3763 deadoffsets[matched_dead_count] != offnum)
3764 {
3765 *all_frozen = all_visible = false;
3766 break;
3767 }
3768 matched_dead_count++;
3769 continue;
3770 }
3771
3773
3777
3778 /* Visibility checks may do IO or allocate memory */
3781 {
3783 {
3784 TransactionId xmin;
3785
3786 /* Check comments in lazy_scan_prune. */
3788 {
3789 all_visible = false;
3790 *all_frozen = false;
3791 break;
3792 }
3793
3794 /*
3795 * The inserter definitely committed. But is it old enough
3796 * that everyone sees it as committed?
3797 */
3800 {
3801 all_visible = false;
3802 *all_frozen = false;
3803 break;
3804 }
3805
3806 /* Track newest xmin on page. */
3808 TransactionIdIsNormal(xmin))
3809 *visibility_cutoff_xid = xmin;
3810
3811 /* Check whether this tuple is already frozen or not */
3812 if (all_visible && *all_frozen &&
3814 *all_frozen = false;
3815 }
3816 break;
3817
3822 {
3823 all_visible = false;
3824 *all_frozen = false;
3825 break;
3826 }
3827 default:
3829 break;
3830 }
3831 } /* scan along page */
3832
3833 /* Clear the offset information once we have processed the given page. */
3835
3836 return all_visible;
3837}
References Assert, buf, BufferGetBlockNumber(), BufferGetPage(), CritSectionCount, elog, ERROR, fb(), FirstOffsetNumber, heap_tuple_needs_eventual_freeze(), HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleHeaderGetXmin(), HeapTupleHeaderXminCommitted(), HeapTupleSatisfiesVacuum(), i, InvalidOffsetNumber, InvalidTransactionId, ItemIdGetLength, ItemIdIsDead, ItemIdIsNormal, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerSet(), OffsetNumberNext, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), RelationGetRelid, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, TransactionIdFollows(), TransactionIdIsNormal, and TransactionIdPrecedes().
Referenced by lazy_vacuum_heap_page().
◆ heap_vac_scan_next_block()
|
static |
Definition at line 1619 of file vacuumlazy.c.
1622{
1625
1626 /* relies on InvalidBlockNumber + 1 overflowing to 0 on first call */
1628
1629 /* Have we reached the end of the relation? */
1631 {
1633 {
1636 }
1638 }
1639
1640 /*
1641 * We must be in one of the three following states:
1642 */
1645 {
1646 /*
1647 * 1. We have just processed an unskippable block (or we're at the
1648 * beginning of the scan). Find the next unskippable block using the
1649 * visibility map.
1650 */
1652
1654
1655 /*
1656 * We now know the next block that we must process. It can be the
1657 * next block after the one we just processed, or something further
1658 * ahead. If it's further ahead, we can jump to it, but we choose to
1659 * do so only if we can skip at least SKIP_PAGES_THRESHOLD consecutive
1660 * pages. Since we're reading sequentially, the OS should be doing
1661 * readahead for us, so there's no gain in skipping a page now and
1662 * then. Skipping such a range might even discourage sequential
1663 * detection.
1664 *
1665 * This test also enables more frequent relfrozenxid advancement
1666 * during non-aggressive VACUUMs. If the range has any all-visible
1667 * pages then skipping makes updating relfrozenxid unsafe, which is a
1668 * real downside.
1669 */
1671 {
1675 }
1676 }
1677
1678 /* Now we must be in one of the two remaining states: */
1680 {
1681 /*
1682 * 2. We are processing a range of blocks that we could have skipped
1683 * but chose not to. We know that they are all-visible in the VM,
1684 * otherwise they would've been unskippable.
1685 */
1687 /* Block was not eager scanned */
1688 *((bool *) per_buffer_data) = false;
1690 }
1691 else
1692 {
1693 /*
1694 * 3. We reached the next unskippable block. Process it. On next
1695 * iteration, we will be back in state 1.
1696 */
1698
1702 }
1703}
References Assert, BufferIsValid(), LVRelState::current_block, fb(), find_next_unskippable_block(), InvalidBlockNumber, InvalidBuffer, ReleaseBuffer(), and SKIP_PAGES_THRESHOLD.
Referenced by lazy_scan_heap().
◆ heap_vacuum_eager_scan_setup()
|
static |
Definition at line 497 of file vacuumlazy.c.
498{
504
505 /*
506 * Initialize eager scan management fields to their disabled values.
507 * Aggressive vacuums, normal vacuums of small tables, and normal vacuums
508 * of tables without sufficiently old tuples disable eager scanning.
509 */
511 vacrel->eager_scan_max_fails_per_region = 0;
512 vacrel->eager_scan_remaining_fails = 0;
513 vacrel->eager_scan_remaining_successes = 0;
514
515 /* If eager scanning is explicitly disabled, just return. */
517 return;
518
519 /*
520 * The caller will have determined whether or not an aggressive vacuum is
521 * required by either the vacuum parameters or the relative age of the
522 * oldest unfrozen transaction IDs. An aggressive vacuum must scan every
523 * all-visible page to safely advance the relfrozenxid and/or relminmxid,
524 * so scans of all-visible pages are not considered eager.
525 */
527 return;
528
529 /*
530 * Aggressively vacuuming a small relation shouldn't take long, so it
531 * isn't worth amortizing. We use two times the region size as the size
532 * cutoff because the eager scan start block is a random spot somewhere in
533 * the first region, making the second region the first to be eager
534 * scanned normally.
535 */
537 return;
538
539 /*
540 * We only want to enable eager scanning if we are likely to be able to
541 * freeze some of the pages in the relation.
542 *
543 * Tuples with XIDs older than OldestXmin or MXIDs older than OldestMxact
544 * are technically freezable, but we won't freeze them unless the criteria
545 * for opportunistic freezing is met. Only tuples with XIDs/MXIDs older
546 * than the FreezeLimit/MultiXactCutoff are frozen in the common case.
547 *
548 * So, as a heuristic, we wait until the FreezeLimit has advanced past the
549 * relfrozenxid or the MultiXactCutoff has advanced past the relminmxid to
550 * enable eager scanning.
551 */
554 vacrel->cutoffs.FreezeLimit))
556
560 vacrel->cutoffs.MultiXactCutoff))
562
564 return;
565
566 /* We have met the criteria to eagerly scan some pages. */
567
568 /*
569 * Our success cap is MAX_EAGER_FREEZE_SUCCESS_RATE of the number of
570 * all-visible but not all-frozen blocks in the relation.
571 */
573
574 vacrel->eager_scan_remaining_successes =
577
578 /* If every all-visible page is frozen, eager scanning is disabled. */
580 return;
581
582 /*
583 * Now calculate the bounds of the first eager scan region. Its end block
584 * will be a random spot somewhere in the first EAGER_SCAN_REGION_SIZE
585 * blocks. This affects the bounds of all subsequent regions and avoids
586 * eager scanning and failing to freeze the same blocks each vacuum of the
587 * relation.
588 */
590
592
594 params.max_eager_freeze_failure_rate <= 1);
595
596 vacrel->eager_scan_max_fails_per_region =
597 params.max_eager_freeze_failure_rate *
599
600 /*
601 * The first region will be smaller than subsequent regions. As such,
602 * adjust the eager freeze failures tolerated for this region.
603 */
606
607 vacrel->eager_scan_remaining_fails =
608 vacrel->eager_scan_max_fails_per_region *
609 first_region_ratio;
610}
References Assert, EAGER_SCAN_REGION_SIZE, fb(), InvalidBlockNumber, VacuumParams::max_eager_freeze_failure_rate, MAX_EAGER_FREEZE_SUCCESS_RATE, MultiXactIdIsValid, MultiXactIdPrecedes(), pg_global_prng_state, pg_prng_uint32(), TransactionIdIsNormal, TransactionIdPrecedes(), and visibilitymap_count().
Referenced by heap_vacuum_rel().
◆ heap_vacuum_rel()
| void heap_vacuum_rel | ( | Relation | rel, |
| const VacuumParams | params, | ||
| BufferAccessStrategy | bstrategy | ||
| ) |
Definition at line 624 of file vacuumlazy.c.
626{
629 instrument,
630 skipwithvm,
631 frozenxid_updated,
632 minmulti_updated;
634 new_rel_pages,
635 new_rel_allvisible,
636 new_rel_allfrozen;
638 TimestampTz starttime = 0;
640 startwritetime = 0;
643 ErrorContextCallback errcallback;
646
649 params.log_vacuum_min_duration >= 0));
650 if (instrument)
651 {
654 {
657 }
658 }
659
660 /* Used for instrumentation and stats report */
661 starttime = GetCurrentTimestamp();
662
664 RelationGetRelid(rel));
667 params.is_wraparound
670 else
673
674 /*
675 * Setup error traceback support for ereport() first. The idea is to set
676 * up an error context callback to display additional information on any
677 * error during a vacuum. During different phases of vacuum, we update
678 * the state so that the error context callback always display current
679 * information.
680 *
681 * Copy the names of heap rel into local memory for error reporting
682 * purposes, too. It isn't always safe to assume that we can get the name
683 * of each rel. It's convenient for code in lazy_scan_heap to always use
684 * these temp copies.
685 */
696 error_context_stack = &errcallback;
697
698 /* Set up high level stuff about rel and its indexes */
699 vacrel->rel = rel;
701 &vacrel->indrels);
702 vacrel->bstrategy = bstrategy;
704 {
705 /* Copy index names used by instrumentation (not error reporting) */
709 }
710
711 /*
712 * The index_cleanup param either disables index vacuuming and cleanup or
713 * forces it to go ahead when we would otherwise apply the index bypass
714 * optimization. The default is 'auto', which leaves the final decision
715 * up to lazy_vacuum().
716 *
717 * The truncate param allows user to avoid attempting relation truncation,
718 * though it can't force truncation to happen.
719 */
723
724 /*
725 * While VacuumFailSafeActive is reset to false before calling this, we
726 * still need to reset it here due to recursive calls.
727 */
734 {
735 /* Force disable index vacuuming up-front */
738 }
740 {
741 /* Force index vacuuming. Note that failsafe can still bypass. */
743 }
744 else
745 {
746 /* Default/auto, make all decisions dynamically */
748 }
749
750 /* Initialize page counters explicitly (be tidy) */
751 vacrel->scanned_pages = 0;
752 vacrel->eager_scanned_pages = 0;
753 vacrel->removed_pages = 0;
754 vacrel->new_frozen_tuple_pages = 0;
755 vacrel->lpdead_item_pages = 0;
756 vacrel->missed_dead_pages = 0;
757 vacrel->nonempty_pages = 0;
758 /* dead_items_alloc allocates vacrel->dead_items later on */
759
760 /* Allocate/initialize output statistics state */
761 vacrel->new_rel_tuples = 0;
762 vacrel->new_live_tuples = 0;
765
766 /* Initialize remaining counters (be tidy) */
767 vacrel->num_index_scans = 0;
768 vacrel->num_dead_items_resets = 0;
769 vacrel->total_dead_items_bytes = 0;
770 vacrel->tuples_deleted = 0;
771 vacrel->tuples_frozen = 0;
772 vacrel->lpdead_items = 0;
773 vacrel->live_tuples = 0;
774 vacrel->recently_dead_tuples = 0;
775 vacrel->missed_dead_tuples = 0;
776
777 vacrel->vm_new_visible_pages = 0;
778 vacrel->vm_new_visible_frozen_pages = 0;
779 vacrel->vm_new_frozen_pages = 0;
780
781 /*
782 * Get cutoffs that determine which deleted tuples are considered DEAD,
783 * not just RECENTLY_DEAD, and which XIDs/MXIDs to freeze. Then determine
784 * the extent of the blocks that we'll scan in lazy_scan_heap. It has to
785 * happen in this order to ensure that the OldestXmin cutoff field works
786 * as an upper bound on the XIDs stored in the pages we'll actually scan
787 * (NewRelfrozenXid tracking must never be allowed to miss unfrozen XIDs).
788 *
789 * Next acquire vistest, a related cutoff that's used in pruning. We use
790 * vistest in combination with OldestXmin to ensure that
791 * heap_page_prune_and_freeze() always removes any deleted tuple whose
792 * xmax is < OldestXmin. lazy_scan_prune must never become confused about
793 * whether a tuple should be frozen or removed. (In the future we might
794 * want to teach lazy_scan_prune to recompute vistest from time to time,
795 * to increase the number of dead tuples it can prune away.)
796 */
800
801 /* Initialize state used to track oldest extant XID/MXID */
804
805 /*
806 * Initialize state related to tracking all-visible page skipping. This is
807 * very important to determine whether or not it is safe to advance the
808 * relfrozenxid/relminmxid.
809 */
811 skipwithvm = true;
813 {
814 /*
815 * Force aggressive mode, and disable skipping blocks using the
816 * visibility map (even those set all-frozen)
817 */
819 skipwithvm = false;
820 }
821
822 vacrel->skipwithvm = skipwithvm;
823
824 /*
825 * Set up eager scan tracking state. This must happen after determining
826 * whether or not the vacuum must be aggressive, because only normal
827 * vacuums use the eager scan algorithm.
828 */
830
831 /* Report the vacuum mode: 'normal' or 'aggressive' */
833 vacrel->aggressive
835 : PROGRESS_VACUUM_MODE_NORMAL);
836
838 {
843 vacrel->relname)));
844 else
848 vacrel->relname)));
849 }
850
851 /*
852 * Allocate dead_items memory using dead_items_alloc. This handles
853 * parallel VACUUM initialization as part of allocating shared memory
854 * space used for dead_items. (But do a failsafe precheck first, to
855 * ensure that parallel VACUUM won't be attempted at all when relfrozenxid
856 * is already dangerously old.)
857 */
860
861 /*
862 * Call lazy_scan_heap to perform all required heap pruning, index
863 * vacuuming, and heap vacuuming (plus related processing)
864 */
866
867 /*
868 * Save dead items max_bytes and update the memory usage statistics before
869 * cleanup, they are freed in parallel vacuum cases during
870 * dead_items_cleanup().
871 */
874
875 /*
876 * Free resources managed by dead_items_alloc. This ends parallel mode in
877 * passing when necessary.
878 */
881
882 /*
883 * Update pg_class entries for each of rel's indexes where appropriate.
884 *
885 * Unlike the later update to rel's pg_class entry, this is not critical.
886 * Maintains relpages/reltuples statistics used by the planner only.
887 */
890
891 /* Done with rel's indexes */
893
894 /* Optionally truncate rel */
897
898 /* Pop the error context stack */
900
901 /* Report that we are now doing final cleanup */
904
905 /*
906 * Prepare to update rel's pg_class entry.
907 *
908 * Aggressive VACUUMs must always be able to advance relfrozenxid to a
909 * value >= FreezeLimit, and relminmxid to a value >= MultiXactCutoff.
910 * Non-aggressive VACUUMs may advance them by any amount, or not at all.
911 */
914 vacrel->cutoffs.relfrozenxid,
915 vacrel->NewRelfrozenXid));
918 vacrel->cutoffs.relminmxid,
919 vacrel->NewRelminMxid));
921 {
922 /*
923 * Must keep original relfrozenxid in a non-aggressive VACUUM that
924 * chose to skip an all-visible page range. The state that tracks new
925 * values will have missed unfrozen XIDs from the pages we skipped.
926 */
930 }
931
932 /*
933 * For safety, clamp relallvisible to be not more than what we're setting
934 * pg_class.relpages to
935 */
940
941 /*
942 * An all-frozen block _must_ be all-visible. As such, clamp the count of
943 * all-frozen blocks to the count of all-visible blocks. This matches the
944 * clamping of relallvisible above.
945 */
948
949 /*
950 * Now actually update rel's pg_class entry.
951 *
952 * In principle new_live_tuples could be -1 indicating that we (still)
953 * don't know the tuple count. In practice that can't happen, since we
954 * scan every page that isn't skipped using the visibility map.
955 */
958 vacrel->nindexes > 0,
961
962 /*
963 * Report results to the cumulative stats system, too.
964 *
965 * Deliberately avoid telling the stats system about LP_DEAD items that
966 * remain in the table due to VACUUM bypassing index and heap vacuuming.
967 * ANALYZE will consider the remaining LP_DEAD items to be dead "tuples".
968 * It seems like a good idea to err on the side of not vacuuming again too
969 * soon in cases where the failsafe prevented significant amounts of heap
970 * vacuuming.
971 */
972 pgstat_report_vacuum(rel,
974 vacrel->recently_dead_tuples +
975 vacrel->missed_dead_tuples,
976 starttime);
977 pgstat_progress_end_command();
978
979 if (instrument)
980 {
982
985 params.log_vacuum_min_duration))
986 {
989 WalUsage walusage;
990 BufferUsage bufferusage;
995 write_rate = 0;
999
1005
1007 bufferusage.local_blks_hit;
1009 bufferusage.local_blks_read;
1011 bufferusage.local_blks_dirtied;
1012
1015 {
1016 /*
1017 * Aggressiveness already reported earlier, in dedicated
1018 * VACUUM VERBOSE ereport
1019 */
1022 }
1024 {
1025 /*
1026 * While it's possible for a VACUUM to be both is_wraparound
1027 * and !aggressive, that's just a corner-case -- is_wraparound
1028 * implies aggressive. Produce distinct output for the corner
1029 * case all the same, just in case.
1030 */
1032 msgfmt = _("automatic aggressive vacuum to prevent wraparound of table \"%s.%s.%s\": index scans: %d\n");
1033 else
1035 }
1036 else
1037 {
1040 else
1042 }
1044 vacrel->dbname,
1045 vacrel->relnamespace,
1046 vacrel->relname,
1047 vacrel->num_index_scans);
1048 appendStringInfo(&buf, _("pages: %u removed, %u remain, %u scanned (%.2f%% of total), %u eagerly scanned\n"),
1049 vacrel->removed_pages,
1050 new_rel_pages,
1051 vacrel->scanned_pages,
1052 orig_rel_pages == 0 ? 100.0 :
1053 100.0 * vacrel->scanned_pages /
1054 orig_rel_pages,
1055 vacrel->eager_scanned_pages);
1057 _("tuples: %" PRId64 " removed, %" PRId64 " remain, %" PRId64 " are dead but not yet removable\n"),
1058 vacrel->tuples_deleted,
1060 vacrel->recently_dead_tuples);
1063 _("tuples missed: %" PRId64 " dead from %u pages not removed due to cleanup lock contention\n"),
1064 vacrel->missed_dead_tuples,
1065 vacrel->missed_dead_pages);
1067 vacrel->cutoffs.OldestXmin);
1072 {
1074 vacrel->cutoffs.relfrozenxid);
1078 }
1080 {
1082 vacrel->cutoffs.relminmxid);
1086 }
1087 appendStringInfo(&buf, _("frozen: %u pages from table (%.2f%% of total) had %" PRId64 " tuples frozen\n"),
1088 vacrel->new_frozen_tuple_pages,
1089 orig_rel_pages == 0 ? 100.0 :
1090 100.0 * vacrel->new_frozen_tuple_pages /
1091 orig_rel_pages,
1092 vacrel->tuples_frozen);
1093
1095 _("visibility map: %u pages set all-visible, %u pages set all-frozen (%u were all-visible)\n"),
1096 vacrel->vm_new_visible_pages,
1097 vacrel->vm_new_visible_frozen_pages +
1098 vacrel->vm_new_frozen_pages,
1099 vacrel->vm_new_frozen_pages);
1101 {
1104 else
1106
1107 msgfmt = _("%u pages from table (%.2f%% of total) had %" PRId64 " dead item identifiers removed\n");
1108 }
1109 else
1110 {
1113 else
1115
1117 }
1119 vacrel->lpdead_item_pages,
1120 orig_rel_pages == 0 ? 100.0 :
1122 vacrel->lpdead_items);
1124 {
1126
1127 if (!istat)
1128 continue;
1129
1133 istat->num_pages,
1134 istat->pages_newly_deleted,
1135 istat->pages_deleted,
1136 istat->pages_free);
1137 }
1139 {
1140 /*
1141 * We bypass the changecount mechanism because this value is
1142 * only updated by the calling process. We also rely on the
1143 * above call to pgstat_progress_end_command() to not clear
1144 * the st_progress_param array.
1145 */
1148 }
1150 {
1153
1156 }
1158 {
1163 }
1168 total_blks_hit,
1169 total_blks_read,
1170 total_blks_dirtied);
1172 _("WAL usage: %" PRId64 " records, %" PRId64 " full page images, %" PRIu64 " bytes, %" PRIu64 " full page image bytes, %" PRId64 " buffers full\n"),
1173 walusage.wal_records,
1174 walusage.wal_fpi,
1175 walusage.wal_bytes,
1176 walusage.wal_fpi_bytes,
1177 walusage.wal_buffers_full);
1178
1179 /*
1180 * Report the dead items memory usage.
1181 *
1182 * The num_dead_items_resets counter increases when we reset the
1183 * collected dead items, so the counter is non-zero if at least
1184 * one dead items are collected, even if index vacuuming is
1185 * disabled.
1186 */
1188 ngettext("memory usage: dead item storage %.2f MB accumulated across %d reset (limit %.2f MB each)\n",
1189 "memory usage: dead item storage %.2f MB accumulated across %d resets (limit %.2f MB each)\n",
1190 vacrel->num_dead_items_resets),
1192 vacrel->num_dead_items_resets,
1195
1199 }
1200 }
1201
1202 /* Cleanup index statistics and index names */
1204 {
1207
1208 if (instrument)
1210 }
1211}
References _, AmAutoVacuumWorkerProcess, appendStringInfo(), appendStringInfoString(), ErrorContextCallback::arg, Assert, buf, BufferUsageAccumDiff(), ErrorContextCallback::callback, dead_items_alloc(), dead_items_cleanup(), ereport, errmsg(), errmsg_internal(), error_context_stack, fb(), get_database_name(), get_namespace_name(), GetCurrentTimestamp(), GlobalVisTestFor(), heap_vacuum_eager_scan_setup(), i, VacuumParams::index_cleanup, INFO, initStringInfo(), InvalidMultiXactId, InvalidTransactionId, VacuumParams::is_wraparound, IsInParallelMode(), lazy_check_wraparound_failsafe(), lazy_scan_heap(), lazy_truncate_heap(), BufferUsage::local_blks_dirtied, BufferUsage::local_blks_hit, BufferUsage::local_blks_read, LOG, VacuumParams::log_vacuum_min_duration, Max, MultiXactIdPrecedesOrEquals(), MyBEEntry, MyDatabaseId, ngettext, NoLock, IndexBulkDeleteResult::num_pages, VacuumParams::nworkers, VacuumParams::options, IndexBulkDeleteResult::pages_deleted, IndexBulkDeleteResult::pages_free, IndexBulkDeleteResult::pages_newly_deleted, palloc0(), palloc0_object, palloc_array, pfree(), pg_rusage_init(), pg_rusage_show(), pgBufferUsage, pgstat_progress_end_command(), pgstat_progress_start_command(), pgstat_progress_update_param(), pgstat_report_vacuum(), pgStatBlockReadTime, pgStatBlockWriteTime, pgWalUsage, ErrorContextCallback::previous, PROGRESS_COMMAND_VACUUM, PROGRESS_VACUUM_DELAY_TIME, PROGRESS_VACUUM_MODE, PROGRESS_VACUUM_MODE_AGGRESSIVE, PROGRESS_VACUUM_MODE_NORMAL, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_FINAL_CLEANUP, PROGRESS_VACUUM_STARTED_BY, PROGRESS_VACUUM_STARTED_BY_AUTOVACUUM, PROGRESS_VACUUM_STARTED_BY_AUTOVACUUM_WRAPAROUND, PROGRESS_VACUUM_STARTED_BY_MANUAL, pstrdup(), ReadNextTransactionId(), RelationGetNamespace, RelationGetNumberOfBlocks, RelationGetRelationName, RelationGetRelid, RowExclusiveLock, BufferUsage::shared_blks_dirtied, BufferUsage::shared_blks_hit, BufferUsage::shared_blks_read, should_attempt_truncation(), PgBackendStatus::st_progress_param, TidStoreMemoryUsage(), TimestampDifference(), TimestampDifferenceExceeds(), track_cost_delay_timing, track_io_timing, TransactionIdPrecedesOrEquals(), VacuumParams::truncate, update_relstats_all_indexes(), vac_close_indexes(), vac_open_indexes(), vac_update_relstats(), VACOPT_DISABLE_PAGE_SKIPPING, VACOPT_VERBOSE, VACOPTVALUE_AUTO, VACOPTVALUE_DISABLED, VACOPTVALUE_ENABLED, VACOPTVALUE_UNSPECIFIED, VACUUM_ERRCB_PHASE_UNKNOWN, vacuum_error_callback(), vacuum_get_cutoffs(), VacuumFailsafeActive, verbose, visibilitymap_count(), WalUsage::wal_buffers_full, WalUsage::wal_bytes, WalUsage::wal_fpi, WalUsage::wal_fpi_bytes, WalUsage::wal_records, and WalUsageAccumDiff().
◆ identify_and_fix_vm_corruption()
|
static |
Definition at line 1980 of file vacuumlazy.c.
1985{
1987
1989
1990 /*
1991 * As of PostgreSQL 9.2, the visibility map bit should never be set if the
1992 * page-level bit is clear. However, it's possible that the bit got
1993 * cleared after heap_vac_scan_next_block() was called, so we must recheck
1994 * with buffer lock before concluding that the VM is corrupt.
1995 */
1998 {
2001 errmsg("page is not marked all-visible but visibility map bit is set in relation \"%s\" page %u",
2003
2005 VISIBILITYMAP_VALID_BITS);
2006 *vmbits = 0;
2007 }
2008
2009 /*
2010 * It's possible for the value returned by
2011 * GetOldestNonRemovableTransactionId() to move backwards, so it's not
2012 * wrong for us to see tuples that appear to not be visible to everyone
2013 * yet, while PD_ALL_VISIBLE is already set. The real safe xmin value
2014 * never moves backwards, but GetOldestNonRemovableTransactionId() is
2015 * conservative and sometimes returns a value that's unnecessarily small,
2016 * so if we see that contradiction it just means that the tuples that we
2017 * think are not visible to everyone yet actually are, and the
2018 * PD_ALL_VISIBLE flag is correct.
2019 *
2020 * There should never be LP_DEAD items on a page with PD_ALL_VISIBLE set,
2021 * however.
2022 */
2024 {
2029
2033 VISIBILITYMAP_VALID_BITS);
2034 *vmbits = 0;
2035 }
2036}
References Assert, BUFFER_LOCK_EXCLUSIVE, BufferIsLockedByMeInMode(), ereport, errcode(), ERRCODE_DATA_CORRUPTED, errmsg(), fb(), MarkBufferDirty(), PageClearAllVisible(), PageIsAllVisible(), RelationGetRelationName, visibilitymap_clear(), visibilitymap_get_status(), VISIBILITYMAP_VALID_BITS, and WARNING.
Referenced by lazy_scan_prune().
◆ lazy_check_wraparound_failsafe()
|
static |
Definition at line 2999 of file vacuumlazy.c.
3000{
3001 /* Don't warn more than once per VACUUM */
3003 return true;
3004
3006 {
3010 PROGRESS_VACUUM_MODE
3011 };
3013
3015
3016 /*
3017 * Abandon use of a buffer access strategy to allow use of all of
3018 * shared buffers. We assume the caller who allocated the memory for
3019 * the BufferAccessStrategy will free it.
3020 */
3022
3023 /* Disable index vacuuming, index cleanup, and heap rel truncation */
3027
3028 /* Reset the progress counters and set the failsafe mode */
3030
3032 (errmsg("bypassing nonessential maintenance of table \"%s.%s.%s\" as a failsafe after %d index scans",
3034 vacrel->num_index_scans),
3036 errhint("Consider increasing configuration parameter \"maintenance_work_mem\" or \"autovacuum_work_mem\".\n"
3037 "You might also need to consider other ways for VACUUM to keep up with the allocation of transaction IDs.")));
3038
3039 /* Stop applying cost limits from this point on */
3041 VacuumCostBalance = 0;
3042
3043 return true;
3044 }
3045
3046 return false;
3047}
References ereport, errdetail(), errhint(), errmsg(), fb(), pgstat_progress_update_multi_param(), PROGRESS_VACUUM_INDEXES_PROCESSED, PROGRESS_VACUUM_INDEXES_TOTAL, PROGRESS_VACUUM_MODE, PROGRESS_VACUUM_MODE_FAILSAFE, unlikely, vacuum_xid_failsafe_check(), VacuumCostActive, VacuumCostBalance, VacuumFailsafeActive, and WARNING.
Referenced by heap_vacuum_rel(), lazy_scan_heap(), and lazy_vacuum_all_indexes().
◆ lazy_cleanup_all_indexes()
|
static |
Definition at line 3053 of file vacuumlazy.c.
3054{
3058 PROGRESS_VACUUM_PHASE,
3060 };
3064 };
3067
3070
3071 /*
3072 * Report that we are now cleaning up indexes and the number of indexes to
3073 * cleanup.
3074 */
3078
3080 {
3082 {
3085
3088 estimated_count, vacrel);
3089
3090 /* Report the number of indexes cleaned up */
3092 idx + 1);
3093 }
3094 }
3095 else
3096 {
3097 /* Outsource everything to parallel variant */
3099 vacrel->num_index_scans,
3100 estimated_count);
3101 }
3102
3103 /* Reset the progress counters */
3105}
References Assert, fb(), idx(), lazy_cleanup_one_index(), parallel_vacuum_cleanup_all_indexes(), ParallelVacuumIsActive, pgstat_progress_update_multi_param(), pgstat_progress_update_param(), PROGRESS_VACUUM_INDEXES_PROCESSED, PROGRESS_VACUUM_INDEXES_TOTAL, PROGRESS_VACUUM_PHASE, and PROGRESS_VACUUM_PHASE_INDEX_CLEANUP.
Referenced by lazy_scan_heap().
◆ lazy_cleanup_one_index()
|
static |
Definition at line 3170 of file vacuumlazy.c.
3173{
3176
3181 ivinfo.estimated_count = estimated_count;
3183
3184 ivinfo.num_heap_tuples = reltuples;
3186
3187 /*
3188 * Update error traceback information.
3189 *
3190 * The index name is saved during this phase and restored immediately
3191 * after this phase. See vacuum_error_callback.
3192 */
3198
3200
3201 /* Revert to the previous phase information for error traceback */
3205
3206 return istat;
3207}
References Assert, DEBUG2, fb(), InvalidBlockNumber, InvalidOffsetNumber, pfree(), pstrdup(), RelationGetRelationName, restore_vacuum_error_info(), update_vacuum_error_info(), vac_cleanup_one_index(), and VACUUM_ERRCB_PHASE_INDEX_CLEANUP.
Referenced by lazy_cleanup_all_indexes().
◆ lazy_scan_heap()
|
static |
Definition at line 1250 of file vacuumlazy.c.
1251{
1252 ReadStream *stream;
1254 blkno = 0,
1255 next_fsm_block_to_vacuum = 0;
1260 PROGRESS_VACUUM_PHASE,
1263 };
1265
1266 /* Report that we're scanning the heap, advertising total # of blocks */
1268 initprog_val[1] = rel_pages;
1271
1272 /* Initialize for the first heap_vac_scan_next_block() call */
1277
1278 /*
1279 * Set up the read stream for vacuum's first pass through the heap.
1280 *
1281 * This could be made safe for READ_STREAM_USE_BATCHING, but only with
1282 * explicit work in heap_vac_scan_next_block.
1283 */
1285 vacrel->bstrategy,
1286 vacrel->rel,
1287 MAIN_FORKNUM,
1288 heap_vac_scan_next_block,
1289 vacrel,
1290 sizeof(bool));
1291
1292 while (true)
1293 {
1295 Page page;
1297 int ndeleted = 0;
1302
1304
1305 /*
1306 * Regularly check if wraparound failsafe should trigger.
1307 *
1308 * There is a similar check inside lazy_vacuum_all_indexes(), but
1309 * relfrozenxid might start to look dangerously old before we reach
1310 * that point. This check also provides failsafe coverage for the
1311 * one-pass strategy, and the two-pass strategy with the index_cleanup
1312 * param set to 'off'.
1313 */
1317
1318 /*
1319 * Consider if we definitely have enough space to process TIDs on page
1320 * already. If we are close to overrunning the available space for
1321 * dead_items TIDs, pause and do a cycle of vacuuming before we tackle
1322 * this page. However, let's force at least one page-worth of tuples
1323 * to be stored as to ensure we do at least some work when the memory
1324 * configured is so low that we run out before storing anything.
1325 */
1328 {
1329 /*
1330 * Before beginning index vacuuming, we release any pin we may
1331 * hold on the visibility map page. This isn't necessary for
1332 * correctness, but we do it anyway to avoid holding the pin
1333 * across a lengthy, unrelated operation.
1334 */
1336 {
1337 ReleaseBuffer(vmbuffer);
1338 vmbuffer = InvalidBuffer;
1339 }
1340
1341 /* Perform a round of index and heap vacuuming */
1344
1345 /*
1346 * Vacuum the Free Space Map to make newly-freed space visible on
1347 * upper-level FSM pages. Note that blkno is the previously
1348 * processed block.
1349 */
1351 blkno + 1);
1352 next_fsm_block_to_vacuum = blkno;
1353
1354 /* Report that we are once again scanning the heap */
1357 }
1358
1360
1361 /* The relation is exhausted. */
1363 break;
1364
1369
1370 vacrel->scanned_pages++;
1372 vacrel->eager_scanned_pages++;
1373
1374 /* Report as block scanned, update error traceback information */
1377 blkno, InvalidOffsetNumber);
1378
1379 /*
1380 * Pin the visibility map page in case we need to mark the page
1381 * all-visible. In most cases this will be very cheap, because we'll
1382 * already have the correct page pinned anyway.
1383 */
1385
1386 /*
1387 * We need a buffer cleanup lock to prune HOT chains and defragment
1388 * the page in lazy_scan_prune. But when it's not possible to acquire
1389 * a cleanup lock right away, we may be able to settle for reduced
1390 * processing using lazy_scan_noprune.
1391 */
1393
1396
1397 /* Check for new or empty pages before lazy_scan_[no]prune call */
1399 vmbuffer))
1400 {
1401 /* Processed as new/empty page (lock and pin released) */
1402 continue;
1403 }
1404
1405 /*
1406 * If we didn't get the cleanup lock, we can still collect LP_DEAD
1407 * items in the dead_items area for later vacuuming, count live and
1408 * recently dead tuples for vacuum logging, and determine if this
1409 * block could later be truncated. If we encounter any xid/mxids that
1410 * require advancing the relfrozenxid/relminxid, we'll have to wait
1411 * for a cleanup lock and call lazy_scan_prune().
1412 */
1415 {
1416 /*
1417 * lazy_scan_noprune could not do all required processing. Wait
1418 * for a cleanup lock, and call lazy_scan_prune in the usual way.
1419 */
1424 }
1425
1426 /*
1427 * If we have a cleanup lock, we must now prune, freeze, and count
1428 * tuples. We may have acquired the cleanup lock originally, or we may
1429 * have gone back and acquired it after lazy_scan_noprune() returned
1430 * false. Either way, the page hasn't been processed yet.
1431 *
1432 * Like lazy_scan_noprune(), lazy_scan_prune() will count
1433 * recently_dead_tuples and live tuples for vacuum logging, determine
1434 * if the block can later be truncated, and accumulate the details of
1435 * remaining LP_DEAD line pointers on the page into dead_items. These
1436 * dead items include those pruned by lazy_scan_prune() as well as
1437 * line pointers previously marked LP_DEAD.
1438 */
1441 vmbuffer,
1443
1444 /*
1445 * Count an eagerly scanned page as a failure or a success.
1446 *
1447 * Only lazy_scan_prune() freezes pages, so if we didn't get the
1448 * cleanup lock, we won't have frozen the page. However, we only count
1449 * pages that were too new to require freezing as eager freeze
1450 * failures.
1451 *
1452 * We could gather more information from lazy_scan_noprune() about
1453 * whether or not there were tuples with XIDs or MXIDs older than the
1454 * FreezeLimit or MultiXactCutoff. However, for simplicity, we simply
1455 * exclude pages skipped due to cleanup lock contention from eager
1456 * freeze algorithm caps.
1457 */
1459 {
1460 /* Aggressive vacuums do not eager scan. */
1462
1464 {
1466 vacrel->eager_scan_remaining_successes--;
1467
1469 {
1470 /*
1471 * Report only once that we disabled eager scanning. We
1472 * may eagerly read ahead blocks in excess of the success
1473 * or failure caps before attempting to freeze them, so we
1474 * could reach here even after disabling additional eager
1475 * scanning.
1476 */
1479 (errmsg("disabling eager scanning after freezing %u eagerly scanned blocks of relation \"%s.%s.%s\"",
1483
1484 /*
1485 * If we hit our success cap, permanently disable eager
1486 * scanning by setting the other eager scan management
1487 * fields to their disabled values.
1488 */
1489 vacrel->eager_scan_remaining_fails = 0;
1491 vacrel->eager_scan_max_fails_per_region = 0;
1492 }
1493 }
1495 vacrel->eager_scan_remaining_fails--;
1496 }
1497
1498 /*
1499 * Now drop the buffer lock and, potentially, update the FSM.
1500 *
1501 * Our goal is to update the freespace map the last time we touch the
1502 * page. If we'll process a block in the second pass, we may free up
1503 * additional space on the page, so it is better to update the FSM
1504 * after the second pass. If the relation has no indexes, or if index
1505 * vacuuming is disabled, there will be no second heap pass; if this
1506 * particular page has no dead items, the second heap pass will not
1507 * touch this page. So, in those cases, update the FSM now.
1508 *
1509 * Note: In corner cases, it's possible to miss updating the FSM
1510 * entirely. If index vacuuming is currently enabled, we'll skip the
1511 * FSM update now. But if failsafe mode is later activated, or there
1512 * are so few dead tuples that index vacuuming is bypassed, there will
1513 * also be no opportunity to update the FSM later, because we'll never
1514 * revisit this page. Since updating the FSM is desirable but not
1515 * absolutely required, that's OK.
1516 */
1518 || !vacrel->do_index_vacuuming
1519 || !has_lpdead_items)
1520 {
1522
1525
1526 /*
1527 * Periodically perform FSM vacuuming to make newly-freed space
1528 * visible on upper FSM pages. This is done after vacuuming if the
1529 * table has indexes. There will only be newly-freed space if we
1530 * held the cleanup lock and lazy_scan_prune() was called.
1531 */
1534 {
1536 blkno);
1537 next_fsm_block_to_vacuum = blkno;
1538 }
1539 }
1540 else
1542 }
1543
1546 ReleaseBuffer(vmbuffer);
1547
1548 /*
1549 * Report that everything is now scanned. We never skip scanning the last
1550 * block in the relation, so we can pass rel_pages here.
1551 */
1553 rel_pages);
1554
1555 /* now we can compute the new value for pg_class.reltuples */
1557 vacrel->scanned_pages,
1558 vacrel->live_tuples);
1559
1560 /*
1561 * Also compute the total number of surviving heap entries. In the
1562 * (unlikely) scenario that new_live_tuples is -1, take it as zero.
1563 */
1564 vacrel->new_rel_tuples =
1566 vacrel->missed_dead_tuples;
1567
1568 read_stream_end(stream);
1569
1570 /*
1571 * Do index vacuuming (call each index's ambulkdelete routine), then do
1572 * related heap vacuuming
1573 */
1576
1577 /*
1578 * Vacuum the remainder of the Free Space Map. We must do this whether or
1579 * not there were indexes, and whether or not we bypassed index vacuuming.
1580 * We can pass rel_pages here because we never skip scanning the last
1581 * block of the relation.
1582 */
1585
1586 /* report all blocks vacuumed */
1588
1589 /* Do final index cleanup (call each index's amvacuumcleanup routine) */
1592}
References Assert, buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), CheckBufferIsPinnedOnce(), ConditionalLockBufferForCleanup(), DEBUG2, ereport, errmsg(), FAILSAFE_EVERY_PAGES, fb(), FreeSpaceMapVacuumRange(), heap_vac_scan_next_block(), INFO, InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, lazy_check_wraparound_failsafe(), lazy_cleanup_all_indexes(), lazy_scan_new_or_empty(), lazy_scan_noprune(), lazy_scan_prune(), lazy_vacuum(), LockBuffer(), LockBufferForCleanup(), MAIN_FORKNUM, Max, PageGetHeapFreeSpace(), pgstat_progress_update_multi_param(), pgstat_progress_update_param(), PROGRESS_VACUUM_HEAP_BLKS_SCANNED, PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, PROGRESS_VACUUM_MAX_DEAD_TUPLE_BYTES, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_SCAN_HEAP, PROGRESS_VACUUM_TOTAL_HEAP_BLKS, read_stream_begin_relation(), read_stream_end(), READ_STREAM_MAINTENANCE, read_stream_next_buffer(), RecordPageWithFreeSpace(), ReleaseBuffer(), TidStoreMemoryUsage(), UnlockReleaseBuffer(), update_vacuum_error_info(), vac_estimate_reltuples(), vacuum_delay_point(), VACUUM_ERRCB_PHASE_SCAN_HEAP, VACUUM_FSM_EVERY_PAGES, and visibilitymap_pin().
Referenced by heap_vacuum_rel().
◆ lazy_scan_new_or_empty()
|
static |
Definition at line 1848 of file vacuumlazy.c.
1850{
1851 Size freespace;
1852
1854 {
1855 /*
1856 * All-zeroes pages can be left over if either a backend extends the
1857 * relation by a single page, but crashes before the newly initialized
1858 * page has been written out, or when bulk-extending the relation
1859 * (which creates a number of empty pages at the tail end of the
1860 * relation), and then enters them into the FSM.
1861 *
1862 * Note we do not enter the page into the visibilitymap. That has the
1863 * downside that we repeatedly visit this page in subsequent vacuums,
1864 * but otherwise we'll never discover the space on a promoted standby.
1865 * The harm of repeated checking ought to normally not be too bad. The
1866 * space usually should be used at some point, otherwise there
1867 * wouldn't be any regular vacuums.
1868 *
1869 * Make sure these pages are in the FSM, to ensure they can be reused.
1870 * Do that by testing if there's any space recorded for the page. If
1871 * not, enter it. We do so after releasing the lock on the heap page,
1872 * the FSM is approximate, after all.
1873 */
1875
1877 {
1879
1881 }
1882
1883 return true;
1884 }
1885
1887 {
1888 /*
1889 * It seems likely that caller will always be able to get a cleanup
1890 * lock on an empty page. But don't take any chances -- escalate to
1891 * an exclusive lock (still don't need a cleanup lock, though).
1892 */
1894 {
1897
1899 {
1900 /* page isn't new or empty -- keep lock and pin for now */
1901 return false;
1902 }
1903 }
1904 else
1905 {
1906 /* Already have a full cleanup lock (which is more than enough) */
1907 }
1908
1909 /*
1910 * Unlike new pages, empty pages are always set all-visible and
1911 * all-frozen.
1912 */
1914 {
1915 START_CRIT_SECTION();
1916
1917 /* mark buffer dirty before writing a WAL record */
1919
1920 /*
1921 * It's possible that another backend has extended the heap,
1922 * initialized the page, and then failed to WAL-log the page due
1923 * to an ERROR. Since heap extension is not WAL-logged, recovery
1924 * might try to replay our record setting the page all-visible and
1925 * find that the page isn't initialized, which will cause a PANIC.
1926 * To prevent that, check whether the page has been previously
1927 * WAL-logged, and if not, do that now.
1928 */
1932
1933 PageSetAllVisible(page);
1935 InvalidXLogRecPtr,
1936 vmbuffer, InvalidTransactionId,
1937 VISIBILITYMAP_ALL_VISIBLE |
1938 VISIBILITYMAP_ALL_FROZEN);
1939 END_CRIT_SECTION();
1940
1941 /* Count the newly all-frozen pages for logging */
1942 vacrel->vm_new_visible_pages++;
1943 vacrel->vm_new_visible_frozen_pages++;
1944 }
1945
1946 freespace = PageGetHeapFreeSpace(page);
1949 return true;
1950 }
1951
1952 /* page isn't new or empty -- keep lock and pin */
1953 return false;
1954}
References buf, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, END_CRIT_SECTION, fb(), GetRecordedFreeSpace(), InvalidTransactionId, InvalidXLogRecPtr, LockBuffer(), log_newpage_buffer(), MarkBufferDirty(), PageGetHeapFreeSpace(), PageGetLSN(), PageIsAllVisible(), PageIsEmpty(), PageIsNew(), PageSetAllVisible(), RecordPageWithFreeSpace(), RelationNeedsWAL, SizeOfPageHeaderData, START_CRIT_SECTION, UnlockReleaseBuffer(), VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, visibilitymap_set(), and XLogRecPtrIsValid.
Referenced by lazy_scan_heap().
◆ lazy_scan_noprune()
|
static |
Definition at line 2269 of file vacuumlazy.c.
2274{
2275 OffsetNumber offnum,
2276 maxoff;
2277 int lpdead_items,
2278 live_tuples,
2279 recently_dead_tuples,
2280 missed_dead_tuples;
2281 bool hastup;
2286
2288
2289 hastup = false; /* for now */
2290
2291 lpdead_items = 0;
2292 live_tuples = 0;
2293 recently_dead_tuples = 0;
2294 missed_dead_tuples = 0;
2295
2296 maxoff = PageGetMaxOffsetNumber(page);
2298 offnum <= maxoff;
2299 offnum = OffsetNumberNext(offnum))
2300 {
2301 ItemId itemid;
2302 HeapTupleData tuple;
2303
2304 vacrel->offnum = offnum;
2305 itemid = PageGetItemId(page, offnum);
2306
2308 continue;
2309
2311 {
2312 hastup = true;
2313 continue;
2314 }
2315
2317 {
2318 /*
2319 * Deliberately don't set hastup=true here. See same point in
2320 * lazy_scan_prune for an explanation.
2321 */
2322 deadoffsets[lpdead_items++] = offnum;
2323 continue;
2324 }
2325
2326 hastup = true; /* page prevents rel truncation */
2329 &NoFreezePageRelfrozenXid,
2330 &NoFreezePageRelminMxid))
2331 {
2332 /* Tuple with XID < FreezeLimit (or MXID < MultiXactCutoff) */
2334 {
2335 /*
2336 * Aggressive VACUUMs must always be able to advance rel's
2337 * relfrozenxid to a value >= FreezeLimit (and be able to
2338 * advance rel's relminmxid to a value >= MultiXactCutoff).
2339 * The ongoing aggressive VACUUM won't be able to do that
2340 * unless it can freeze an XID (or MXID) from this tuple now.
2341 *
2342 * The only safe option is to have caller perform processing
2343 * of this page using lazy_scan_prune. Caller might have to
2344 * wait a while for a cleanup lock, but it can't be helped.
2345 */
2347 return false;
2348 }
2349
2350 /*
2351 * Non-aggressive VACUUMs are under no obligation to advance
2352 * relfrozenxid (even by one XID). We can be much laxer here.
2353 *
2354 * Currently we always just accept an older final relfrozenxid
2355 * and/or relminmxid value. We never make caller wait or work a
2356 * little harder, even when it likely makes sense to do so.
2357 */
2358 }
2359
2364
2366 buf))
2367 {
2370
2371 /*
2372 * Count both cases as live, just like lazy_scan_prune
2373 */
2374 live_tuples++;
2375
2376 break;
2378
2379 /*
2380 * There is some useful work for pruning to do, that won't be
2381 * done due to failure to get a cleanup lock.
2382 */
2383 missed_dead_tuples++;
2384 break;
2386
2387 /*
2388 * Count in recently_dead_tuples, just like lazy_scan_prune
2389 */
2390 recently_dead_tuples++;
2391 break;
2393
2394 /*
2395 * Do not count these rows as live, just like lazy_scan_prune
2396 */
2397 break;
2398 default:
2400 break;
2401 }
2402 }
2403
2405
2406 /*
2407 * By here we know for sure that caller can put off freezing and pruning
2408 * this particular page until the next VACUUM. Remember its details now.
2409 * (lazy_scan_prune expects a clean slate, so we have to do this last.)
2410 */
2411 vacrel->NewRelfrozenXid = NoFreezePageRelfrozenXid;
2412 vacrel->NewRelminMxid = NoFreezePageRelminMxid;
2413
2414 /* Save any LP_DEAD items found on the page in dead_items */
2416 {
2417 /* Using one-pass strategy (since table has no indexes) */
2418 if (lpdead_items > 0)
2419 {
2420 /*
2421 * Perfunctory handling for the corner case where a single pass
2422 * strategy VACUUM cannot get a cleanup lock, and it turns out
2423 * that there is one or more LP_DEAD items: just count the LP_DEAD
2424 * items as missed_dead_tuples instead. (This is a bit dishonest,
2425 * but it beats having to maintain specialized heap vacuuming code
2426 * forever, for vanishingly little benefit.)
2427 */
2428 hastup = true;
2429 missed_dead_tuples += lpdead_items;
2430 }
2431 }
2432 else if (lpdead_items > 0)
2433 {
2434 /*
2435 * Page has LP_DEAD items, and so any references/TIDs that remain in
2436 * indexes will be deleted during index vacuuming (and then marked
2437 * LP_UNUSED in the heap)
2438 */
2439 vacrel->lpdead_item_pages++;
2440
2442
2443 vacrel->lpdead_items += lpdead_items;
2444 }
2445
2446 /*
2447 * Finally, add relevant page-local counts to whole-VACUUM counts
2448 */
2449 vacrel->live_tuples += live_tuples;
2450 vacrel->recently_dead_tuples += recently_dead_tuples;
2451 vacrel->missed_dead_tuples += missed_dead_tuples;
2452 if (missed_dead_tuples > 0)
2453 vacrel->missed_dead_pages++;
2454
2455 /* Can't truncate this page */
2456 if (hastup)
2457 vacrel->nonempty_pages = blkno + 1;
2458
2459 /* Did we find LP_DEAD items? */
2460 *has_lpdead_items = (lpdead_items > 0);
2461
2462 /* Caller won't need to call lazy_scan_prune with same page */
2463 return true;
2464}
References Assert, buf, BufferGetBlockNumber(), dead_items_add(), elog, ERROR, fb(), FirstOffsetNumber, heap_tuple_should_freeze(), HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleSatisfiesVacuum(), InvalidOffsetNumber, ItemIdGetLength, ItemIdIsDead, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerSet(), MaxHeapTuplesPerPage, OffsetNumberNext, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), RelationGetRelid, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, and HeapTupleData::t_tableOid.
Referenced by lazy_scan_heap().
◆ lazy_scan_prune()
|
static |
Definition at line 2056 of file vacuumlazy.c.
2063{
2066 PruneFreezeParams params = {
2067 .relation = rel,
2068 .buffer = buf,
2069 .reason = PRUNE_VACUUM_SCAN,
2070 .options = HEAP_PAGE_PRUNE_FREEZE,
2071 .vistest = vacrel->vistest,
2072 .cutoffs = &vacrel->cutoffs,
2073 };
2076
2078
2079 /*
2080 * Prune all HOT-update chains and potentially freeze tuples on this page.
2081 *
2082 * If the relation has no indexes, we can immediately mark would-be dead
2083 * items LP_UNUSED.
2084 *
2085 * The number of tuples removed from the page is returned in
2086 * presult.ndeleted. It should not be confused with presult.lpdead_items;
2087 * presult.lpdead_items's final value can be thought of as the number of
2088 * tuples that were deleted from indexes.
2089 *
2090 * We will update the VM after collecting LP_DEAD items and freezing
2091 * tuples. Pruning will have determined whether or not the page is
2092 * all-visible.
2093 */
2096
2097 heap_page_prune_and_freeze(¶ms,
2098 &presult,
2099 &vacrel->offnum,
2101
2104
2106 {
2107 /*
2108 * We don't increment the new_frozen_tuple_pages instrumentation
2109 * counter when nfrozen == 0, since it only counts pages with newly
2110 * frozen tuples (don't confuse that with pages newly set all-frozen
2111 * in VM).
2112 */
2113 vacrel->new_frozen_tuple_pages++;
2114 }
2115
2116 /*
2117 * VACUUM will call heap_page_is_all_visible() during the second pass over
2118 * the heap to determine all_visible and all_frozen for the page -- this
2119 * is a specialized version of the logic from this function. Now that
2120 * we've finished pruning and freezing, make sure that we're in total
2121 * agreement with heap_page_is_all_visible() using an assertion.
2122 */
2123#ifdef USE_ASSERT_CHECKING
2125 {
2128
2130
2134
2136
2139 }
2140#endif
2141
2142 /*
2143 * Now save details of the LP_DEAD items from the page in vacrel
2144 */
2146 {
2147 vacrel->lpdead_item_pages++;
2148
2149 /*
2150 * deadoffsets are collected incrementally in
2151 * heap_page_prune_and_freeze() as each dead line pointer is recorded,
2152 * with an indeterminate order, but dead_items_add requires them to be
2153 * sorted.
2154 */
2156 cmpOffsetNumbers);
2157
2159 }
2160
2161 /* Finally, add page-local counts to whole-VACUUM counts */
2167
2168 /* Can't truncate this page */
2170 vacrel->nonempty_pages = blkno + 1;
2171
2172 /* Did we find LP_DEAD items? */
2174
2177
2179
2181 presult.lpdead_items, vmbuffer,
2182 &old_vmbits);
2183
2186
2187 /* Set the visibility map and page visibility hint */
2189
2192
2193 /* Nothing to do */
2196
2197 /*
2198 * It should never be the case that the visibility map page is set while
2199 * the page-level bit is clear (and if so, we cleared it above), but the
2200 * reverse is allowed (if checksums are not enabled). Regardless, set both
2201 * bits so that we get back in sync.
2202 *
2203 * The heap buffer must be marked dirty before adding it to the WAL chain
2204 * when setting the VM. We don't worry about unnecessarily dirtying the
2205 * heap buffer if PD_ALL_VISIBLE is already set, though. It is extremely
2206 * rare to have a clean heap buffer with PD_ALL_VISIBLE already set and
2207 * the VM bits clear, so there is no point in optimizing it.
2208 */
2209 PageSetAllVisible(page);
2211
2212 /*
2213 * If the page is being set all-frozen, we pass InvalidTransactionId as
2214 * the cutoff_xid, since a snapshot conflict horizon sufficient to make
2215 * everything safe for REDO was logged when the page's tuples were frozen.
2216 */
2219
2221 InvalidXLogRecPtr,
2222 vmbuffer, presult.vm_conflict_horizon,
2223 new_vmbits);
2224
2225 /*
2226 * If the page wasn't already set all-visible and/or all-frozen in the VM,
2227 * count it as newly set for logging.
2228 */
2230 {
2231 vacrel->vm_new_visible_pages++;
2233 {
2234 vacrel->vm_new_visible_frozen_pages++;
2236 }
2237 }
2239 presult.all_frozen)
2240 {
2241 vacrel->vm_new_frozen_pages++;
2243 }
2244
2246}
References Assert, buf, BufferGetBlockNumber(), cmpOffsetNumbers(), dead_items_add(), fb(), heap_page_prune_and_freeze(), HEAP_PAGE_PRUNE_FREEZE, HEAP_PAGE_PRUNE_MARK_UNUSED_NOW, identify_and_fix_vm_corruption(), InvalidXLogRecPtr, MarkBufferDirty(), MultiXactIdIsValid, PruneFreezeParams::options, PageSetAllVisible(), PRUNE_VACUUM_SCAN, qsort, PruneFreezeParams::relation, TransactionIdIsValid, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, visibilitymap_get_status(), and visibilitymap_set().
Referenced by lazy_scan_heap().
◆ lazy_truncate_heap()
|
static |
Definition at line 3250 of file vacuumlazy.c.
3251{
3256
3257 /* Report that we are now truncating */
3260
3261 /* Update error traceback information one last time */
3264
3265 /*
3266 * Loop until no more truncating can be done.
3267 */
3268 do
3269 {
3270 /*
3271 * We need full exclusive lock on the relation in order to do
3272 * truncation. If we can't get it, give up rather than waiting --- we
3273 * don't want to block other backends, and we don't want to deadlock
3274 * (which is quite possible considering we already hold a lower-grade
3275 * lock).
3276 */
3278 lock_retry = 0;
3279 while (true)
3280 {
3282 break;
3283
3284 /*
3285 * Check for interrupts while trying to (re-)acquire the exclusive
3286 * lock.
3287 */
3288 CHECK_FOR_INTERRUPTS();
3289
3292 {
3293 /*
3294 * We failed to establish the lock in the specified number of
3295 * retries. This means we give up truncating.
3296 */
3300 return;
3301 }
3302
3306 WAIT_EVENT_VACUUM_TRUNCATE);
3308 }
3309
3310 /*
3311 * Now that we have exclusive lock, look to see if the rel has grown
3312 * whilst we were vacuuming with non-exclusive lock. If so, give up;
3313 * the newly added pages presumably contain non-deletable tuples.
3314 */
3317 {
3318 /*
3319 * Note: we intentionally don't update vacrel->rel_pages with the
3320 * new rel size here. If we did, it would amount to assuming that
3321 * the new pages are empty, which is unlikely. Leaving the numbers
3322 * alone amounts to assuming that the new pages have the same
3323 * tuple density as existing ones, which is less unlikely.
3324 */
3326 return;
3327 }
3328
3329 /*
3330 * Scan backwards from the end to verify that the end pages actually
3331 * contain no tuples. This is *necessary*, not optional, because
3332 * other backends could have added tuples to these pages whilst we
3333 * were vacuuming.
3334 */
3337
3339 {
3340 /* can't do anything after all */
3342 return;
3343 }
3344
3345 /*
3346 * Okay to truncate.
3347 */
3349
3350 /*
3351 * We can release the exclusive lock as soon as we have truncated.
3352 * Other backends can't safely access the relation until they have
3353 * processed the smgr invalidation that smgrtruncate sent out ... but
3354 * that should happen as part of standard invalidation processing once
3355 * they acquire lock on the relation.
3356 */
3358
3359 /*
3360 * Update statistics. Here, it *is* correct to adjust rel_pages
3361 * without also touching reltuples, since the tuple count wasn't
3362 * changed by the truncation.
3363 */
3366
3373}
References AccessExclusiveLock, CHECK_FOR_INTERRUPTS, ConditionalLockRelation(), count_nondeletable_pages(), DEBUG2, ereport, errmsg(), fb(), INFO, InvalidOffsetNumber, MyLatch, pgstat_progress_update_param(), PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_TRUNCATE, RelationGetNumberOfBlocks, RelationTruncate(), ResetLatch(), UnlockRelation(), update_vacuum_error_info(), VACUUM_ERRCB_PHASE_TRUNCATE, VACUUM_TRUNCATE_LOCK_TIMEOUT, VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL, WaitLatch(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, and WL_TIMEOUT.
Referenced by heap_vacuum_rel().
◆ lazy_vacuum()
|
static |
Definition at line 2480 of file vacuumlazy.c.
2481{
2483
2484 /* Should not end up here with no indexes */
2487
2489 {
2492 return;
2493 }
2494
2495 /*
2496 * Consider bypassing index vacuuming (and heap vacuuming) entirely.
2497 *
2498 * We currently only do this in cases where the number of LP_DEAD items
2499 * for the entire VACUUM operation is close to zero. This avoids sharp
2500 * discontinuities in the duration and overhead of successive VACUUM
2501 * operations that run against the same table with a fixed workload.
2502 * Ideally, successive VACUUM operations will behave as if there are
2503 * exactly zero LP_DEAD items in cases where there are close to zero.
2504 *
2505 * This is likely to be helpful with a table that is continually affected
2506 * by UPDATEs that can mostly apply the HOT optimization, but occasionally
2507 * have small aberrations that lead to just a few heap pages retaining
2508 * only one or two LP_DEAD items. This is pretty common; even when the
2509 * DBA goes out of their way to make UPDATEs use HOT, it is practically
2510 * impossible to predict whether HOT will be applied in 100% of cases.
2511 * It's far easier to ensure that 99%+ of all UPDATEs against a table use
2512 * HOT through careful tuning.
2513 */
2516 {
2518
2523
2524 /*
2525 * This crossover point at which we'll start to do index vacuuming is
2526 * expressed as a percentage of the total number of heap pages in the
2527 * table that are known to have at least one LP_DEAD item. This is
2528 * much more important than the total number of LP_DEAD items, since
2529 * it's a proxy for the number of heap pages whose visibility map bits
2530 * cannot be set on account of bypassing index and heap vacuuming.
2531 *
2532 * We apply one further precautionary test: the space currently used
2533 * to store the TIDs (TIDs that now all point to LP_DEAD items) must
2534 * not exceed 32MB. This limits the risk that we will bypass index
2535 * vacuuming again and again until eventually there is a VACUUM whose
2536 * dead_items space is not CPU cache resident.
2537 *
2538 * We don't take any special steps to remember the LP_DEAD items (such
2539 * as counting them in our final update to the stats system) when the
2540 * optimization is applied. Though the accounting used in analyze.c's
2541 * acquire_sample_rows() will recognize the same LP_DEAD items as dead
2542 * rows in its own stats report, that's okay. The discrepancy should
2543 * be negligible. If this optimization is ever expanded to cover more
2544 * cases then this may need to be reconsidered.
2545 */
2549 }
2550
2552 {
2553 /*
2554 * There are almost zero TIDs. Behave as if there were precisely
2555 * zero: bypass index vacuuming, but do index cleanup.
2556 *
2557 * We expect that the ongoing VACUUM operation will finish very
2558 * quickly, so there is no point in considering speeding up as a
2559 * failsafe against wraparound failure. (Index cleanup is expected to
2560 * finish very quickly in cases where there were no ambulkdelete()
2561 * calls.)
2562 */
2564 }
2566 {
2567 /*
2568 * We successfully completed a round of index vacuuming. Do related
2569 * heap vacuuming now.
2570 */
2572 }
2573 else
2574 {
2575 /*
2576 * Failsafe case.
2577 *
2578 * We attempted index vacuuming, but didn't finish a full round/full
2579 * index scan. This happens when relfrozenxid or relminmxid is too
2580 * far in the past.
2581 *
2582 * From this point on the VACUUM operation will do no further index
2583 * vacuuming or heap vacuuming. This VACUUM operation won't end up
2584 * back here again.
2585 */
2587 }
2588
2589 /*
2590 * Forget the LP_DEAD items that we just vacuumed (or just decided to not
2591 * vacuum)
2592 */
2594}
References Assert, BYPASS_THRESHOLD_PAGES, dead_items_reset(), fb(), lazy_vacuum_all_indexes(), lazy_vacuum_heap_rel(), TidStoreMemoryUsage(), and VacuumFailsafeActive.
Referenced by lazy_scan_heap().
◆ lazy_vacuum_all_indexes()
|
static |
Definition at line 2605 of file vacuumlazy.c.
2606{
2610 PROGRESS_VACUUM_PHASE,
2612 };
2617 };
2620
2624
2625 /* Precheck for XID wraparound emergencies */
2627 {
2628 /* Wraparound emergency -- don't even start an index scan */
2629 return false;
2630 }
2631
2632 /*
2633 * Report that we are now vacuuming indexes and the number of indexes to
2634 * vacuum.
2635 */
2639
2641 {
2643 {
2646
2648 old_live_tuples,
2649 vacrel);
2650
2651 /* Report the number of indexes vacuumed */
2653 idx + 1);
2654
2656 {
2657 /* Wraparound emergency -- end current index scan */
2659 break;
2660 }
2661 }
2662 }
2663 else
2664 {
2665 /* Outsource everything to parallel variant */
2667 vacrel->num_index_scans);
2668
2669 /*
2670 * Do a postcheck to consider applying wraparound failsafe now. Note
2671 * that parallel VACUUM only gets the precheck and this postcheck.
2672 */
2675 }
2676
2677 /*
2678 * We delete all LP_DEAD items from the first heap pass in all indexes on
2679 * each call here (except calls where we choose to do the failsafe). This
2680 * makes the next call to lazy_vacuum_heap_rel() safe (except in the event
2681 * of the failsafe triggering, which prevents the next call from taking
2682 * place).
2683 */
2687
2688 /*
2689 * Increase and report the number of index scans. Also, we reset
2690 * PROGRESS_VACUUM_INDEXES_TOTAL and PROGRESS_VACUUM_INDEXES_PROCESSED.
2691 *
2692 * We deliberately include the case where we started a round of bulk
2693 * deletes that we weren't able to finish due to the failsafe triggering.
2694 */
2695 vacrel->num_index_scans++;
2696 progress_end_val[0] = 0;
2697 progress_end_val[1] = 0;
2700
2702}
References Assert, fb(), idx(), lazy_check_wraparound_failsafe(), lazy_vacuum_one_index(), parallel_vacuum_bulkdel_all_indexes(), ParallelVacuumIsActive, pgstat_progress_update_multi_param(), pgstat_progress_update_param(), PROGRESS_VACUUM_INDEXES_PROCESSED, PROGRESS_VACUUM_INDEXES_TOTAL, PROGRESS_VACUUM_NUM_INDEX_VACUUMS, PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_VACUUM_INDEX, and VacuumFailsafeActive.
Referenced by lazy_vacuum().
◆ lazy_vacuum_heap_page()
|
static |
Definition at line 2868 of file vacuumlazy.c.
2871{
2874 int nunused = 0;
2875 TransactionId visibility_cutoff_xid;
2877 bool all_frozen;
2880
2882
2884
2885 /* Update error traceback information */
2887 VACUUM_ERRCB_PHASE_VACUUM_HEAP, blkno,
2888 InvalidOffsetNumber);
2889
2890 /*
2891 * Before marking dead items unused, check whether the page will become
2892 * all-visible once that change is applied. This lets us reap the tuples
2893 * and mark the page all-visible within the same critical section,
2894 * enabling both changes to be emitted in a single WAL record. Since the
2895 * visibility checks may perform I/O and allocate memory, they must be
2896 * done outside the critical section.
2897 */
2899 vacrel->cutoffs.OldestXmin,
2900 deadoffsets, num_offsets,
2901 &all_frozen, &visibility_cutoff_xid,
2902 &vacrel->offnum))
2903 {
2905 if (all_frozen)
2906 {
2909 }
2910
2911 /*
2912 * Take the lock on the vmbuffer before entering a critical section.
2913 * The heap page lock must also be held while updating the VM to
2914 * ensure consistency.
2915 */
2917 }
2918
2919 START_CRIT_SECTION();
2920
2922 {
2923 ItemId itemid;
2925
2927
2929 ItemIdSetUnused(itemid);
2930 unused[nunused++] = toff;
2931 }
2932
2933 Assert(nunused > 0);
2934
2935 /* Attempt to truncate line pointer array now */
2936 PageTruncateLinePointerArray(page);
2937
2939 {
2940 /*
2941 * The page is guaranteed to have had dead line pointers, so we always
2942 * set PD_ALL_VISIBLE.
2943 */
2944 PageSetAllVisible(page);
2945 visibilitymap_set_vmbits(blkno,
2946 vmbuffer, vmflags,
2947 vacrel->rel->rd_locator);
2948 conflict_xid = visibility_cutoff_xid;
2949 }
2950
2951 /*
2952 * Mark buffer dirty before we write WAL.
2953 */
2954 MarkBufferDirty(buffer);
2955
2956 /* XLOG stuff */
2958 {
2961 vmflags,
2962 conflict_xid,
2964 PRUNE_VACUUM_CLEANUP,
2968 unused, nunused);
2969 }
2970
2971 END_CRIT_SECTION();
2972
2974 {
2975 /* Count the newly set VM page for logging */
2977 vacrel->vm_new_visible_pages++;
2978 if (all_frozen)
2979 vacrel->vm_new_visible_frozen_pages++;
2980 }
2981
2982 /* Revert to the previous phase information for error traceback */
2984}
References Assert, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetPage(), END_CRIT_SECTION, fb(), heap_page_would_be_all_visible(), i, InvalidBuffer, InvalidOffsetNumber, InvalidTransactionId, ItemIdHasStorage, ItemIdIsDead, ItemIdSetUnused, LockBuffer(), log_heap_prune_and_freeze(), MarkBufferDirty(), MaxHeapTuplesPerPage, PageGetItemId(), PageSetAllVisible(), PageTruncateLinePointerArray(), pgstat_progress_update_param(), PROGRESS_VACUUM_HEAP_BLKS_VACUUMED, PRUNE_VACUUM_CLEANUP, RelationNeedsWAL, restore_vacuum_error_info(), START_CRIT_SECTION, TransactionIdIsValid, update_vacuum_error_info(), VACUUM_ERRCB_PHASE_VACUUM_HEAP, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_ALL_VISIBLE, visibilitymap_set_vmbits(), and VISIBILITYMAP_VALID_BITS.
Referenced by lazy_vacuum_heap_rel().
◆ lazy_vacuum_heap_rel()
|
static |
Definition at line 2750 of file vacuumlazy.c.
2751{
2752 ReadStream *stream;
2756 TidStoreIter *iter;
2757
2761
2762 /* Report that we are now vacuuming the heap */
2765
2766 /* Update error traceback information */
2770
2772
2773 /*
2774 * Set up the read stream for vacuum's second pass through the heap.
2775 *
2776 * It is safe to use batchmode, as vacuum_reap_lp_read_stream_next() does
2777 * not need to wait for IO and does not perform locking. Once we support
2778 * parallelism it should still be fine, as presumably the holder of locks
2779 * would never be blocked by IO while holding the lock.
2780 */
2782 READ_STREAM_USE_BATCHING,
2783 vacrel->bstrategy,
2784 vacrel->rel,
2785 MAIN_FORKNUM,
2787 iter,
2789
2790 while (true)
2791 {
2792 BlockNumber blkno;
2794 Page page;
2796 Size freespace;
2799
2801
2803
2804 /* The relation is exhausted */
2806 break;
2807
2809
2813
2814 /*
2815 * Pin the visibility map page in case we need to mark the page
2816 * all-visible. In most cases this will be very cheap, because we'll
2817 * already have the correct page pinned anyway.
2818 */
2820
2821 /* We need a non-cleanup exclusive lock to mark dead_items unused */
2824 num_offsets, vmbuffer);
2825
2826 /* Now that we've vacuumed the page, record its available space */
2828 freespace = PageGetHeapFreeSpace(page);
2829
2832 vacuumed_pages++;
2833 }
2834
2835 read_stream_end(stream);
2836 TidStoreEndIterate(iter);
2837
2840 ReleaseBuffer(vmbuffer);
2841
2842 /*
2843 * We set all LP_DEAD items from the first heap pass to LP_UNUSED during
2844 * the second heap pass. No more, no less.
2845 */
2849
2853 vacuumed_pages)));
2854
2855 /* Revert to the previous phase information for error traceback */
2857}
References Assert, buf, BUFFER_LOCK_EXCLUSIVE, BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), DEBUG2, ereport, errmsg(), fb(), InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, lazy_vacuum_heap_page(), lengthof, LockBuffer(), MAIN_FORKNUM, MaxOffsetNumber, PageGetHeapFreeSpace(), pgstat_progress_update_param(), PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_VACUUM_HEAP, read_stream_begin_relation(), read_stream_end(), READ_STREAM_MAINTENANCE, read_stream_next_buffer(), READ_STREAM_USE_BATCHING, RecordPageWithFreeSpace(), ReleaseBuffer(), restore_vacuum_error_info(), TidStoreBeginIterate(), TidStoreEndIterate(), TidStoreGetBlockOffsets(), UnlockReleaseBuffer(), update_vacuum_error_info(), vacuum_delay_point(), VACUUM_ERRCB_PHASE_VACUUM_HEAP, vacuum_reap_lp_read_stream_next(), and visibilitymap_pin().
Referenced by lazy_vacuum().
◆ lazy_vacuum_one_index()
|
static |
Definition at line 3121 of file vacuumlazy.c.
3123{
3126
3133 ivinfo.num_heap_tuples = reltuples;
3135
3136 /*
3137 * Update error traceback information.
3138 *
3139 * The index name is saved during this phase and restored immediately
3140 * after this phase. See vacuum_error_callback.
3141 */
3147
3148 /* Do bulk deletion */
3150 vacrel->dead_items_info);
3151
3152 /* Revert to the previous phase information for error traceback */
3156
3157 return istat;
3158}
References Assert, DEBUG2, fb(), InvalidBlockNumber, InvalidOffsetNumber, pfree(), pstrdup(), RelationGetRelationName, restore_vacuum_error_info(), update_vacuum_error_info(), vac_bulkdel_one_index(), and VACUUM_ERRCB_PHASE_VACUUM_INDEX.
Referenced by lazy_vacuum_all_indexes().
◆ restore_vacuum_error_info()
|
static |
Definition at line 3961 of file vacuumlazy.c.
3963{
3967}
References fb().
Referenced by lazy_cleanup_one_index(), lazy_vacuum_heap_page(), lazy_vacuum_heap_rel(), and lazy_vacuum_one_index().
◆ should_attempt_truncation()
|
static |
Definition at line 3230 of file vacuumlazy.c.
3231{
3233
3235 return false;
3236
3241 return true;
3242
3243 return false;
3244}
References fb(), REL_TRUNCATE_FRACTION, REL_TRUNCATE_MINIMUM, and VacuumFailsafeActive.
Referenced by heap_vacuum_rel().
◆ update_relstats_all_indexes()
|
static |
Definition at line 3843 of file vacuumlazy.c.
3844{
3848
3850
3852 {
3855
3857 continue;
3858
3859 /* Update index statistics */
3861 istat->num_pages,
3862 istat->num_index_tuples,
3863 0, 0,
3864 false,
3865 InvalidTransactionId,
3866 InvalidMultiXactId,
3868 }
3869}
References Assert, IndexBulkDeleteResult::estimated_count, fb(), idx(), InvalidMultiXactId, InvalidTransactionId, IndexBulkDeleteResult::num_index_tuples, IndexBulkDeleteResult::num_pages, and vac_update_relstats().
Referenced by heap_vacuum_rel().
◆ update_vacuum_error_info()
|
static |
Definition at line 3942 of file vacuumlazy.c.
3944{
3946 {
3950 }
3951
3952 vacrel->blkno = blkno;
3953 vacrel->offnum = offnum;
3954 vacrel->phase = phase;
3955}
References fb().
Referenced by lazy_cleanup_one_index(), lazy_scan_heap(), lazy_truncate_heap(), lazy_vacuum_heap_page(), lazy_vacuum_heap_rel(), and lazy_vacuum_one_index().
◆ vacuum_error_callback()
Definition at line 3878 of file vacuumlazy.c.
3879{
3881
3883 {
3886 {
3890 else
3893 }
3894 else
3897 break;
3898
3901 {
3905 else
3908 }
3909 else
3912 break;
3913
3917 break;
3918
3922 break;
3923
3928 break;
3929
3931 default:
3932 return; /* do nothing; the errinfo may not be
3933 * initialized */
3934 }
3935}
References arg, BlockNumberIsValid(), errcontext, fb(), OffsetNumberIsValid, VACUUM_ERRCB_PHASE_INDEX_CLEANUP, VACUUM_ERRCB_PHASE_SCAN_HEAP, VACUUM_ERRCB_PHASE_TRUNCATE, VACUUM_ERRCB_PHASE_UNKNOWN, VACUUM_ERRCB_PHASE_VACUUM_HEAP, and VACUUM_ERRCB_PHASE_VACUUM_INDEX.
Referenced by heap_vacuum_rel().
◆ vacuum_reap_lp_read_stream_next()
|
static |
Definition at line 2712 of file vacuumlazy.c.
2715{
2716 TidStoreIter *iter = callback_private_data;
2718
2722
2723 /*
2724 * Save the TidStoreIterResult for later, so we can extract the offsets.
2725 * It is safe to copy the result, according to TidStoreIterateNext().
2726 */
2728
2730}
References fb(), InvalidBlockNumber, and TidStoreIterateNext().
Referenced by lazy_vacuum_heap_rel().
