From d0dba3c28dbf8915db4df731edb445e5064f97bb Mon Sep 17 00:00:00 2001 From: "Imseih (AWS)" Date: Fri, 4 Nov 2022 07:48:42 -0500 Subject: [PATCH v14 1/2] Add 2 new columns to pg_stat_progress_vacuum. The columns are indexes_total as the total indexes to be vacuumed or cleaned and indexes_processed as the number of indexes vacuumed or cleaned up so far. Author: Sami Imseih, based on suggestions by Nathan Bossart, Peter Geoghegan and Masahiko Sawada Reviewed by: Nathan Bossart, Masahiko Sawada Discussion: https://www.postgresql.org/message-id/flat/5478DFCD-2333-401A-B2F0-0D186AB09228@amazon.com --- contrib/bloom/blvacuum.c | 6 +++ doc/src/sgml/monitoring.sgml | 21 +++++++++ src/backend/access/brin/brin.c | 9 ++-- src/backend/access/gin/ginvacuum.c | 9 ++++ src/backend/access/gist/gistvacuum.c | 5 +++ src/backend/access/hash/hash.c | 8 +++- src/backend/access/hash/hashpage.c | 4 +- src/backend/access/heap/vacuumlazy.c | 40 ++++++++++++++++- src/backend/access/nbtree/nbtree.c | 3 ++ src/backend/access/spgist/spgvacuum.c | 3 ++ src/backend/access/transam/parallel.c | 5 +++ src/backend/catalog/index.c | 1 + src/backend/catalog/system_views.sql | 3 +- src/backend/commands/vacuumparallel.c | 63 ++++++++++++++++++++++++++- src/include/access/genam.h | 3 ++ src/include/access/hash.h | 3 +- src/include/access/parallel.h | 2 + src/include/commands/progress.h | 2 + src/include/commands/vacuum.h | 2 + src/test/regress/expected/rules.out | 4 +- 20 files changed, 184 insertions(+), 12 deletions(-) 10.5% doc/src/sgml/ 5.8% src/backend/access/brin/ 4.4% src/backend/access/gin/ 6.2% src/backend/access/hash/ 17.7% src/backend/access/heap/ 7.5% src/backend/access/ 32.8% src/backend/commands/ 6.1% src/include/access/ 5.6% src/ diff --git a/contrib/bloom/blvacuum.c b/contrib/bloom/blvacuum.c index 91fae5b0c0..19ae819cfe 100644 --- a/contrib/bloom/blvacuum.c +++ b/contrib/bloom/blvacuum.c @@ -136,6 +136,9 @@ blbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats, GenericXLogAbort(gxlogState); } UnlockReleaseBuffer(buffer); + + if (info->report_parallel_progress) + info->parallel_progress_callback(info->parallel_progress_arg); } /* @@ -209,6 +212,9 @@ blvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats) } UnlockReleaseBuffer(buffer); + + if (info->report_parallel_progress) + info->parallel_progress_callback(info->parallel_progress_arg); } IndexFreeSpaceMapVacuum(info->index); diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml index e5d622d514..c61443f3d5 100644 --- a/doc/src/sgml/monitoring.sgml +++ b/doc/src/sgml/monitoring.sgml @@ -6455,6 +6455,27 @@ FROM pg_stat_get_backend_idset() AS backendid; Number of dead tuples collected since the last index vacuum cycle. + + + + indexes_total bigint + + + Number of indexes that wil be vacuumed. This value will be + 0 if there are no indexes to vacuum or + vacuum failsafe is triggered. See + for more on vacuum failsafe. + + + + + + indexes_completed bigint + + + Number of indexes vacuumed in the current vacuum cycle. + + diff --git a/src/backend/access/brin/brin.c b/src/backend/access/brin/brin.c index 20b7d65b94..bd96ecf41e 100644 --- a/src/backend/access/brin/brin.c +++ b/src/backend/access/brin/brin.c @@ -78,7 +78,7 @@ static void brinsummarize(Relation index, Relation heapRel, BlockNumber pageRang static void form_and_insert_tuple(BrinBuildState *state); static void union_tuples(BrinDesc *bdesc, BrinMemTuple *a, BrinTuple *b); -static void brin_vacuum_scan(Relation idxrel, BufferAccessStrategy strategy); +static void brin_vacuum_scan(Relation idxrel, BufferAccessStrategy strategy, IndexVacuumInfo *info); static bool add_values_to_range(Relation idxRel, BrinDesc *bdesc, BrinMemTuple *dtup, Datum *values, bool *nulls); static bool check_null_keys(BrinValues *bval, ScanKey *nullkeys, int nnullkeys); @@ -952,7 +952,7 @@ brinvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats) heapRel = table_open(IndexGetRelation(RelationGetRelid(info->index), false), AccessShareLock); - brin_vacuum_scan(info->index, info->strategy); + brin_vacuum_scan(info->index, info->strategy, info); brinsummarize(info->index, heapRel, BRIN_ALL_BLOCKRANGES, false, &stats->num_index_tuples, &stats->num_index_tuples); @@ -1659,7 +1659,7 @@ union_tuples(BrinDesc *bdesc, BrinMemTuple *a, BrinTuple *b) * and such. */ static void -brin_vacuum_scan(Relation idxrel, BufferAccessStrategy strategy) +brin_vacuum_scan(Relation idxrel, BufferAccessStrategy strategy, IndexVacuumInfo *info) { BlockNumber nblocks; BlockNumber blkno; @@ -1681,6 +1681,9 @@ brin_vacuum_scan(Relation idxrel, BufferAccessStrategy strategy) brin_page_cleanup(idxrel, buf); ReleaseBuffer(buf); + + if (info->report_parallel_progress) + info->parallel_progress_callback(info->parallel_progress_arg); } /* diff --git a/src/backend/access/gin/ginvacuum.c b/src/backend/access/gin/ginvacuum.c index b4fa5f6bf8..3d5e4600dc 100644 --- a/src/backend/access/gin/ginvacuum.c +++ b/src/backend/access/gin/ginvacuum.c @@ -633,6 +633,9 @@ ginbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats, UnlockReleaseBuffer(buffer); buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno, RBM_NORMAL, info->strategy); + + if (info->report_parallel_progress) + info->parallel_progress_callback(info->parallel_progress_arg); } /* right now we found leftmost page in entry's BTree */ @@ -677,6 +680,9 @@ ginbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats, buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno, RBM_NORMAL, info->strategy); LockBuffer(buffer, GIN_EXCLUSIVE); + + if (info->report_parallel_progress) + info->parallel_progress_callback(info->parallel_progress_arg); } MemoryContextDelete(gvs.tmpCxt); @@ -775,6 +781,9 @@ ginvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats) } UnlockReleaseBuffer(buffer); + + if (info->report_parallel_progress) + info->parallel_progress_callback(info->parallel_progress_arg); } /* Update the metapage with accurate page and entry counts */ diff --git a/src/backend/access/gist/gistvacuum.c b/src/backend/access/gist/gistvacuum.c index 0aa6e58a62..da3a0540d0 100644 --- a/src/backend/access/gist/gistvacuum.c +++ b/src/backend/access/gist/gistvacuum.c @@ -223,7 +223,12 @@ gistvacuumscan(IndexVacuumInfo *info, IndexBulkDeleteResult *stats, break; /* Iterate over pages, then loop back to recheck length */ for (; blkno < num_pages; blkno++) + { gistvacuumpage(&vstate, blkno, blkno); + + if (info->report_parallel_progress) + info->parallel_progress_callback(info->parallel_progress_arg); + } } /* diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c index c361509d68..14790adf61 100644 --- a/src/backend/access/hash/hash.c +++ b/src/backend/access/hash/hash.c @@ -550,7 +550,7 @@ loop_top: cachedmetap->hashm_highmask, cachedmetap->hashm_lowmask, &tuples_removed, &num_index_tuples, split_cleanup, - callback, callback_state); + callback, callback_state, info); _hash_dropbuf(rel, bucket_buf); @@ -686,7 +686,8 @@ hashbucketcleanup(Relation rel, Bucket cur_bucket, Buffer bucket_buf, uint32 maxbucket, uint32 highmask, uint32 lowmask, double *tuples_removed, double *num_index_tuples, bool split_cleanup, - IndexBulkDeleteCallback callback, void *callback_state) + IndexBulkDeleteCallback callback, void *callback_state, + IndexVacuumInfo *info) { BlockNumber blkno; Buffer buf; @@ -775,6 +776,9 @@ hashbucketcleanup(Relation rel, Bucket cur_bucket, Buffer bucket_buf, if (num_index_tuples) *num_index_tuples += 1; } + + if (info && info->report_parallel_progress) + info->parallel_progress_callback(info->parallel_progress_arg); } /* retain the pin on primary bucket page till end of bucket scan */ diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c index d2edcd4617..e9ce1a1110 100644 --- a/src/backend/access/hash/hashpage.c +++ b/src/backend/access/hash/hashpage.c @@ -759,7 +759,7 @@ restart_expand: hashbucketcleanup(rel, old_bucket, buf_oblkno, start_oblkno, NULL, maxbucket, highmask, lowmask, NULL, NULL, true, - NULL, NULL); + NULL, NULL, NULL); _hash_dropbuf(rel, buf_oblkno); @@ -1327,7 +1327,7 @@ _hash_splitbucket(Relation rel, hashbucketcleanup(rel, obucket, bucket_obuf, BufferGetBlockNumber(bucket_obuf), NULL, maxbucket, highmask, lowmask, NULL, NULL, true, - NULL, NULL); + NULL, NULL, NULL); } else { diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index dfbe37472f..120a2b18d7 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -420,6 +420,10 @@ heap_vacuum_rel(Relation rel, VacuumParams *params, vacrel->rel = rel; vac_open_indexes(vacrel->rel, RowExclusiveLock, &vacrel->nindexes, &vacrel->indrels); + + /* report number of indexes to vacuum */ + pgstat_progress_update_param(PROGRESS_VACUUM_INDEX_TOTAL, vacrel->nindexes); + if (instrument && vacrel->nindexes > 0) { /* Copy index names used by instrumentation (not error reporting) */ @@ -2341,6 +2345,12 @@ lazy_vacuum_all_indexes(LVRelState *vacrel) lazy_vacuum_one_index(indrel, istat, vacrel->old_live_tuples, vacrel); + /* + * Done vacuuming an index. Increment the indexes completed + */ + pgstat_progress_update_param(PROGRESS_VACUUM_INDEX_COMPLETED, + idx + 1); + if (lazy_check_wraparound_failsafe(vacrel)) { /* Wraparound emergency -- end current index scan */ @@ -2384,6 +2394,13 @@ lazy_vacuum_all_indexes(LVRelState *vacrel) pgstat_progress_update_param(PROGRESS_VACUUM_NUM_INDEX_VACUUMS, vacrel->num_index_scans); + /* + * Reset the indexes completed at this point. + * If we end up in another index vacuum cycle, we will + * start counting from the start. + */ + pgstat_progress_update_param(PROGRESS_VACUUM_INDEX_COMPLETED, 0); + return allindexes; } @@ -2633,10 +2650,17 @@ lazy_check_wraparound_failsafe(LVRelState *vacrel) { vacrel->failsafe_active = true; - /* Disable index vacuuming, index cleanup, and heap rel truncation */ + /* + * Disable index vacuuming, index cleanup, and heap rel truncation + * + * Also, report to progress.h that we are no longer tracking + * index vacuum/cleanup. + */ vacrel->do_index_vacuuming = false; vacrel->do_index_cleanup = false; vacrel->do_rel_truncate = false; + pgstat_progress_update_param(PROGRESS_VACUUM_INDEX_TOTAL, 0); + pgstat_progress_update_param(PROGRESS_VACUUM_INDEX_COMPLETED, 0); ereport(WARNING, (errmsg("bypassing nonessential maintenance of table \"%s.%s.%s\" as a failsafe after %d index scans", @@ -2684,6 +2708,12 @@ lazy_cleanup_all_indexes(LVRelState *vacrel) vacrel->indstats[idx] = lazy_cleanup_one_index(indrel, istat, reltuples, estimated_count, vacrel); + + /* + * Done cleaning an index. Increment the indexes completed + */ + pgstat_progress_update_param(PROGRESS_VACUUM_INDEX_COMPLETED, + idx + 1); } } else @@ -2693,6 +2723,12 @@ lazy_cleanup_all_indexes(LVRelState *vacrel) vacrel->num_index_scans, estimated_count); } + + /* + * Reset the indexes completed at this point. + */ + pgstat_progress_update_param(PROGRESS_VACUUM_INDEX_COMPLETED, 0); + } /* @@ -2718,6 +2754,7 @@ lazy_vacuum_one_index(Relation indrel, IndexBulkDeleteResult *istat, ivinfo.index = indrel; ivinfo.analyze_only = false; ivinfo.report_progress = false; + ivinfo.report_parallel_progress = false; ivinfo.estimated_count = true; ivinfo.message_level = DEBUG2; ivinfo.num_heap_tuples = reltuples; @@ -2766,6 +2803,7 @@ lazy_cleanup_one_index(Relation indrel, IndexBulkDeleteResult *istat, ivinfo.index = indrel; ivinfo.analyze_only = false; ivinfo.report_progress = false; + ivinfo.report_parallel_progress = false; ivinfo.estimated_count = estimated_count; ivinfo.message_level = DEBUG2; diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c index b52eca8f38..9904a9eb0c 100644 --- a/src/backend/access/nbtree/nbtree.c +++ b/src/backend/access/nbtree/nbtree.c @@ -998,6 +998,9 @@ btvacuumscan(IndexVacuumInfo *info, IndexBulkDeleteResult *stats, if (info->report_progress) pgstat_progress_update_param(PROGRESS_SCAN_BLOCKS_DONE, scanblkno); + + if (info->report_parallel_progress) + info->parallel_progress_callback(info->parallel_progress_arg); } } diff --git a/src/backend/access/spgist/spgvacuum.c b/src/backend/access/spgist/spgvacuum.c index 0049630532..b1ab491980 100644 --- a/src/backend/access/spgist/spgvacuum.c +++ b/src/backend/access/spgist/spgvacuum.c @@ -843,6 +843,9 @@ spgvacuumscan(spgBulkDeleteState *bds) /* empty the pending-list after each page */ if (bds->pendingList != NULL) spgprocesspending(bds); + + if (bds->info->report_parallel_progress) + bds->info->parallel_progress_callback(bds->info->parallel_progress_arg); } } diff --git a/src/backend/access/transam/parallel.c b/src/backend/access/transam/parallel.c index ee0985c7ed..0b4bde8297 100644 --- a/src/backend/access/transam/parallel.c +++ b/src/backend/access/transam/parallel.c @@ -185,6 +185,8 @@ CreateParallelContext(const char *library_name, const char *function_name, pcxt->library_name = pstrdup(library_name); pcxt->function_name = pstrdup(function_name); pcxt->error_context_stack = error_context_stack; + pcxt->parallel_progress_callback = NULL; + pcxt->parallel_progress_arg = NULL; shm_toc_initialize_estimator(&pcxt->estimator); dlist_push_head(&pcxt_list, &pcxt->node); @@ -785,6 +787,9 @@ WaitForParallelWorkersToFinish(ParallelContext *pcxt) */ CHECK_FOR_INTERRUPTS(); + if (pcxt->parallel_progress_callback) + pcxt->parallel_progress_callback(pcxt->parallel_progress_arg); + for (i = 0; i < pcxt->nworkers_launched; ++i) { /* diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c index 61f1d3926a..11b32129a7 100644 --- a/src/backend/catalog/index.c +++ b/src/backend/catalog/index.c @@ -3348,6 +3348,7 @@ validate_index(Oid heapId, Oid indexId, Snapshot snapshot) ivinfo.index = indexRelation; ivinfo.analyze_only = false; ivinfo.report_progress = true; + ivinfo.report_parallel_progress = false; ivinfo.estimated_count = true; ivinfo.message_level = DEBUG2; ivinfo.num_heap_tuples = heapRelation->rd_rel->reltuples; diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql index 2d8104b090..c37b20b91b 100644 --- a/src/backend/catalog/system_views.sql +++ b/src/backend/catalog/system_views.sql @@ -1165,7 +1165,8 @@ CREATE VIEW pg_stat_progress_vacuum AS END AS phase, S.param2 AS heap_blks_total, S.param3 AS heap_blks_scanned, S.param4 AS heap_blks_vacuumed, S.param5 AS index_vacuum_count, - S.param6 AS max_dead_tuples, S.param7 AS num_dead_tuples + S.param6 AS max_dead_tuples, S.param7 AS num_dead_tuples, + S.param8 AS indexes_total, S.param9 AS indexes_completed FROM pg_stat_get_progress_info('VACUUM') AS S LEFT JOIN pg_database D ON S.datid = D.oid; diff --git a/src/backend/commands/vacuumparallel.c b/src/backend/commands/vacuumparallel.c index f26d796e52..85e2de5d54 100644 --- a/src/backend/commands/vacuumparallel.c +++ b/src/backend/commands/vacuumparallel.c @@ -30,6 +30,7 @@ #include "access/table.h" #include "access/xact.h" #include "catalog/index.h" +#include "commands/progress.h" #include "commands/vacuum.h" #include "optimizer/paths.h" #include "pgstat.h" @@ -103,6 +104,17 @@ typedef struct PVShared /* Counter for vacuuming and cleanup */ pg_atomic_uint32 idx; + + /* + * Counter for vacuuming and cleanup progress reporting. + * This value is used to report index vacuum/cleanup progress + * in parallel_vacuum_progress_report. We keep this + * counter to avoid having to loop through + * ParallelVacuumState->indstats to determine the number + * of indexes completed. + */ + pg_atomic_uint32 idx_completed_progress; + } PVShared; /* Status used during parallel index vacuum or cleanup */ @@ -273,6 +285,9 @@ parallel_vacuum_init(Relation rel, Relation *indrels, int nindexes, Assert(pcxt->nworkers > 0); pvs->pcxt = pcxt; + pvs->pcxt->parallel_progress_callback = parallel_vacuum_progress_report; + pvs->pcxt->parallel_progress_arg = pvs; + /* Estimate size for index vacuum stats -- PARALLEL_VACUUM_KEY_INDEX_STATS */ est_indstats_len = mul_size(sizeof(PVIndStats), nindexes); shm_toc_estimate_chunk(&pcxt->estimator, est_indstats_len); @@ -364,6 +379,7 @@ parallel_vacuum_init(Relation rel, Relation *indrels, int nindexes, pg_atomic_init_u32(&(shared->cost_balance), 0); pg_atomic_init_u32(&(shared->active_nworkers), 0); pg_atomic_init_u32(&(shared->idx), 0); + pg_atomic_init_u32(&(shared->idx_completed_progress), 0); shm_toc_insert(pcxt->toc, PARALLEL_VACUUM_KEY_SHARED, shared); pvs->shared = shared; @@ -618,8 +634,9 @@ parallel_vacuum_process_all_indexes(ParallelVacuumState *pvs, int num_index_scan vacuum)); } - /* Reset the parallel index processing counter */ + /* Reset the parallel index processing counter ( index progress counter also ) */ pg_atomic_write_u32(&(pvs->shared->idx), 0); + pg_atomic_write_u32(&(pvs->shared->idx_completed_progress), 0); /* Setup the shared cost-based vacuum delay and launch workers */ if (nworkers > 0) @@ -834,10 +851,13 @@ parallel_vacuum_process_one_index(ParallelVacuumState *pvs, Relation indrel, ivinfo.index = indrel; ivinfo.analyze_only = false; ivinfo.report_progress = false; + ivinfo.report_parallel_progress = true; ivinfo.message_level = DEBUG2; ivinfo.estimated_count = pvs->shared->estimated_count; ivinfo.num_heap_tuples = pvs->shared->reltuples; ivinfo.strategy = pvs->bstrategy; + ivinfo.parallel_progress_callback = parallel_vacuum_progress_report; + ivinfo.parallel_progress_arg = pvs; /* Update error traceback information */ pvs->indname = pstrdup(RelationGetRelationName(indrel)); @@ -846,9 +866,11 @@ parallel_vacuum_process_one_index(ParallelVacuumState *pvs, Relation indrel, switch (indstats->status) { case PARALLEL_INDVAC_STATUS_NEED_BULKDELETE: + pgstat_progress_update_param(PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_VACUUM_INDEX); istat_res = vac_bulkdel_one_index(&ivinfo, istat, pvs->dead_items); break; case PARALLEL_INDVAC_STATUS_NEED_CLEANUP: + pgstat_progress_update_param(PROGRESS_VACUUM_PHASE, PROGRESS_VACUUM_PHASE_INDEX_CLEANUP); istat_res = vac_cleanup_one_index(&ivinfo, istat); break; default: @@ -888,6 +910,11 @@ parallel_vacuum_process_one_index(ParallelVacuumState *pvs, Relation indrel, pvs->status = PARALLEL_INDVAC_STATUS_COMPLETED; pfree(pvs->indname); pvs->indname = NULL; + + /* + * Update the number of indexes completed. + */ + pg_atomic_add_fetch_u32(&(pvs->shared->idx_completed_progress), 1); } /* @@ -1072,3 +1099,37 @@ parallel_vacuum_error_callback(void *arg) return; } } + +/* + * Read the number of indexes vacuumed from the shared counter + * and report it to progress.h + * + * This function is only called by the leader process of + * a parallel vacuum. + * + * If report_parallel_progress is set to true, + * this function is called from major loops inside the + * ambulkdelete and amvacuumcleanup. + * + * This function is also called inside WaitForParallelWorkersToFinish + * when report_parallel_progress is set to true. + * + * The reason for calling this function in both vacuum AM's + * and WaitForParallelWorkersToFinish is to ensure that + * parallel vacuum progress is constantly being reported + * if the leader process is either waiting for parallel + * proceses to finish (WaitForParallelWorkersToFinish) or + * the leader process is the last to finish and still + * inside the vacuum AM's. + */ +void +parallel_vacuum_progress_report(void *arg) +{ + ParallelVacuumState *pvs = (ParallelVacuumState *) arg; + + if (IsParallelWorker()) + return; + + pgstat_progress_update_param(PROGRESS_VACUUM_INDEX_COMPLETED, + pg_atomic_read_u32(&(pvs->shared->idx_completed_progress))); +} diff --git a/src/include/access/genam.h b/src/include/access/genam.h index e1c4fdbd03..6d5fc189f4 100644 --- a/src/include/access/genam.h +++ b/src/include/access/genam.h @@ -46,10 +46,13 @@ typedef struct IndexVacuumInfo Relation index; /* the index being vacuumed */ bool analyze_only; /* ANALYZE (without any actual vacuum) */ bool report_progress; /* emit progress.h status reports */ + bool report_parallel_progress; /* emit progress.h status reports for parallel vacuum */ bool estimated_count; /* num_heap_tuples is an estimate */ int message_level; /* ereport level for progress messages */ double num_heap_tuples; /* tuples remaining in heap */ BufferAccessStrategy strategy; /* access strategy for reads */ + void (*parallel_progress_callback)(void *arg); + void *parallel_progress_arg; } IndexVacuumInfo; /* diff --git a/src/include/access/hash.h b/src/include/access/hash.h index da372841c4..14fb75a4ad 100644 --- a/src/include/access/hash.h +++ b/src/include/access/hash.h @@ -480,6 +480,7 @@ extern void hashbucketcleanup(Relation rel, Bucket cur_bucket, uint32 maxbucket, uint32 highmask, uint32 lowmask, double *tuples_removed, double *num_index_tuples, bool split_cleanup, - IndexBulkDeleteCallback callback, void *callback_state); + IndexBulkDeleteCallback callback, void *callback_state, + IndexVacuumInfo *info); #endif /* HASH_H */ diff --git a/src/include/access/parallel.h b/src/include/access/parallel.h index 1ec8e33af4..77e9c0a517 100644 --- a/src/include/access/parallel.h +++ b/src/include/access/parallel.h @@ -46,6 +46,8 @@ typedef struct ParallelContext ParallelWorkerInfo *worker; int nknown_attached_workers; bool *known_attached_workers; + void (*parallel_progress_callback)(void *arg); + void *parallel_progress_arg; } ParallelContext; typedef struct ParallelWorkerContext diff --git a/src/include/commands/progress.h b/src/include/commands/progress.h index a28938caf4..0e97c6d4ef 100644 --- a/src/include/commands/progress.h +++ b/src/include/commands/progress.h @@ -25,6 +25,8 @@ #define PROGRESS_VACUUM_NUM_INDEX_VACUUMS 4 #define PROGRESS_VACUUM_MAX_DEAD_TUPLES 5 #define PROGRESS_VACUUM_NUM_DEAD_TUPLES 6 +#define PROGRESS_VACUUM_INDEX_TOTAL 7 +#define PROGRESS_VACUUM_INDEX_COMPLETED 8 /* Phases of vacuum (as advertised via PROGRESS_VACUUM_PHASE) */ #define PROGRESS_VACUUM_PHASE_SCAN_HEAP 1 diff --git a/src/include/commands/vacuum.h b/src/include/commands/vacuum.h index 5d816ba7f4..9510d028d3 100644 --- a/src/include/commands/vacuum.h +++ b/src/include/commands/vacuum.h @@ -338,4 +338,6 @@ extern double anl_random_fract(void); extern double anl_init_selection_state(int n); extern double anl_get_next_S(double t, int n, double *stateptr); +extern void parallel_vacuum_progress_report(void *arg); + #endif /* VACUUM_H */ diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out index 624d0e5aae..e0bf81247f 100644 --- a/src/test/regress/expected/rules.out +++ b/src/test/regress/expected/rules.out @@ -2018,7 +2018,9 @@ pg_stat_progress_vacuum| SELECT s.pid, s.param4 AS heap_blks_vacuumed, s.param5 AS index_vacuum_count, s.param6 AS max_dead_tuples, - s.param7 AS num_dead_tuples + s.param7 AS num_dead_tuples, + s.param8 AS indexes_total, + s.param9 AS indexes_completed FROM (pg_stat_get_progress_info('VACUUM'::text) s(pid, datid, relid, param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15, param16, param17, param18, param19, param20) LEFT JOIN pg_database d ON ((s.datid = d.oid))); pg_stat_recovery_prefetch| SELECT s.stats_reset, -- 2.32.1 (Apple Git-133)