From d2e0358e4d3c498afcc7ddaa7a84a7d79e921008 Mon Sep 17 00:00:00 2001 From: Nitin Jadhav Date: Fri, 25 Feb 2022 14:47:59 +0000 Subject: [PATCH] pg_stat_progress_checkpoint view --- doc/src/sgml/monitoring.sgml | 357 +++++++++++++++++++++++++++ doc/src/sgml/ref/checkpoint.sgml | 6 + doc/src/sgml/wal.sgml | 5 +- src/backend/access/transam/xlog.c | 79 ++++++ src/backend/catalog/system_views.sql | 35 +++ src/backend/storage/buffer/bufmgr.c | 7 + src/backend/storage/sync/sync.c | 6 + src/backend/utils/adt/pgstatfuncs.c | 49 ++++ src/include/catalog/pg_proc.dat | 12 + src/include/commands/progress.h | 28 +++ src/include/utils/backend_progress.h | 3 +- src/test/regress/expected/rules.out | 32 +++ 12 files changed, 617 insertions(+), 2 deletions(-) diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml index bf7625d988..6dfc9bc392 100644 --- a/doc/src/sgml/monitoring.sgml +++ b/doc/src/sgml/monitoring.sgml @@ -401,6 +401,13 @@ postgres 27093 0.0 0.0 30096 2752 ? Ss 11:34 0:00 postgres: ser See . + + + pg_stat_progress_checkpointpg_stat_progress_checkpoint + One row only, showing the progress of the checkpoint. + See . + + @@ -6895,6 +6902,356 @@ SELECT pg_stat_get_backend_pid(s.backendid) AS pid, + + Checkpoint Progress Reporting + + + pg_stat_progress_checkpoint + + + + Whenever the checkpoint operation is running, the + pg_stat_progress_checkpoint view will contain a + single row indicating the progress of the checkpoint. The tables below + describe the information that will be reported and provide information about + how to interpret it. + + + + <structname>pg_stat_progress_checkpoint</structname> View + + + + + Column Type + + + Description + + + + + + + + pid integer + + + Process ID of the checkpointer process. + + + + + + type text + + + Type of checkpoint. See . + + + + + + kind text + + + Kind of checkpoint. See . + + + + + + start_lsn text + + + The checkpoint start location. + + + + + + start_time timestamp with time zone + + + Elapsed time of the checkpoint. + + + + + + phase text + + + Current processing phase. See . + + + + + + buffers_total bigint + + + Total number of buffers to be written. This is estimated and reported + as of the beginning of buffer write operation. + + + + + + buffers_processed bigint + + + Number of buffers processed. This counter increases when the targeted + buffer is processed. This number will eventually become equal to + total_buffer_writes when the checkpoint is + complete. + + + + + + buffers_written bigint + + + Number of buffers written. This counter only advances when the targeted + buffers is written. Note that some of the buffers are processed but may + not required to be written. So this count will always be less than or + equal to total_buffer_writes. + + + + + + files_total bigint + + + Total number of files to be synced. This is estimated and reported as of + the beginning of sync operation. + + + + + + files_synced bigint + + + Number of files synced. This counter advances when the targeted file is + synced. This number will eventually become equal to + total_file_syncs when the checkpoint is complete. + + + + +
+ + + Checkpoint types + + + + + + Types + Description + + + + + checkpoint + + The current operation is checkpoint. + + + + restartpoint + + The current operation is restartpoint. + + + + +
+ + + Checkpoint kinds + + + + + + Kinds + Description + + + + + shutdown + + The checkpoint is for shutdown. + + + + end-of-recovery + + The checkpoint is for end-of-recovery. + + + + immediate + + The checkpoint is happens without delays. + + + + force + + The checkpoint is started because some operation forced a checkpoint. + + + + flush all + + The checkpoint flushes all pages, including those belonging to unlogged + tables. + + + + wait + + Wait for completion before returning. + + + + requested + + The checkpoint request has been made. + + + + wal + + The checkpoint is started because max_wal_size is + reached. + + + + time + + The checkpoint is started because checkpoint_timeout + expired. + + + + +
+ + + Checkpoint phases + + + + + + Phase + Description + + + + + initializing + + The checkpointer process is preparing to begin the checkpoint operation. + This phase is expected to be very brief. + + + + checkpointing replication slots + + The checkpointer process is currently flushing all the replication slots + to disk. + + + + checkpointing snapshots + + The checkpointer process is currently removing all the serialized + snapshots that are not required anymore. + + + + checkpointing logical rewrite mappings + + The checkpointer process is currently removing/flushing the logical + rewrite mappings. + + + + checkpointing commit log pages + + The checkpointer process is currently writing commit log pages to disk. + + + + checkpointing commit time stamp pages + + The checkpointer process is currently writing commit time stamp pages to + disk. + + + + checkpointing subtransaction pages + + The checkpointer process is currently writing subtransaction pages to disk. + + + + checkpointing multixact pages + + The checkpointer process is currently writing multixact pages to disk. + + + + checkpointing SLRU pages + + The checkpointer process is currently writing SLRU pages to disk. + + + + checkpointing buffers + + The checkpointer process is currently writing buffers to disk. + + + + performing sync requests + + The checkpointer process is currently performing sync requests. + + + + performing two phase checkpoint + + The checkpointer process is currently performing two phase checkpoint. + + + + recycling old XLOG files + + The checkpointer process is currently recycling old XLOG files. + + + + finalizing + + The checkpointer process is finalizing the checkpoint operation. + + + + +
+ + + diff --git a/doc/src/sgml/ref/checkpoint.sgml b/doc/src/sgml/ref/checkpoint.sgml index 1cebc03d15..a88c76533a 100644 --- a/doc/src/sgml/ref/checkpoint.sgml +++ b/doc/src/sgml/ref/checkpoint.sgml @@ -56,6 +56,12 @@ CHECKPOINT the pg_checkpointer role can call CHECKPOINT. + + + The checkpointer process running the checkpoint will report its progress + in the pg_stat_progress_checkpoint view. See + for details. + diff --git a/doc/src/sgml/wal.sgml b/doc/src/sgml/wal.sgml index 2bb27a8468..a75d1d63d0 100644 --- a/doc/src/sgml/wal.sgml +++ b/doc/src/sgml/wal.sgml @@ -530,7 +530,10 @@ adjust the parameter rather than the checkpoint parameters.) It is also possible to force a checkpoint by using the SQL - command CHECKPOINT. + command CHECKPOINT. The checkpointer process running the + checkpoint will report its progress in the + pg_stat_progress_checkpoint view. See + for details. diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index 0d2bd7a357..af6e64c836 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -65,6 +65,7 @@ #include "catalog/catversion.h" #include "catalog/pg_control.h" #include "catalog/pg_database.h" +#include "commands/progress.h" #include "common/controldata_utils.h" #include "executor/instrument.h" #include "miscadmin.h" @@ -719,6 +720,8 @@ static void WALInsertLockAcquireExclusive(void); static void WALInsertLockRelease(void); static void WALInsertLockUpdateInsertingAt(XLogRecPtr insertingAt); +static void checkpoint_progress_start(int flags); + /* * Insert an XLOG record represented by an already-constructed chain of data * chunks. This is a low-level routine; to construct the WAL record header @@ -6296,6 +6299,9 @@ CreateCheckPoint(int flags) MemSet(&CheckpointStats, 0, sizeof(CheckpointStats)); CheckpointStats.ckpt_start_t = GetCurrentTimestamp(); + /* Prepare to report progress of the checkpoint. */ + checkpoint_progress_start(flags); + /* * Use a critical section to force system panic if we have trouble. */ @@ -6394,6 +6400,7 @@ CreateCheckPoint(int flags) curInsert += SizeOfXLogShortPHD; } checkPoint.redo = curInsert; + pgstat_progress_update_param(PROGRESS_CHECKPOINT_LSN, checkPoint.redo); /* * Here we update the shared RedoRecPtr for future XLogInsert calls; this @@ -6629,8 +6636,12 @@ CreateCheckPoint(int flags) KeepLogSeg(recptr, &_logSegNo); } _logSegNo--; + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_OLD_XLOG_RECYCLE); RemoveOldXlogFiles(_logSegNo, RedoRecPtr, recptr, checkPoint.ThisTimeLineID); + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_FINALIZE); /* * Make more log segments if needed. (Do this after recycling old log @@ -6652,6 +6663,9 @@ CreateCheckPoint(int flags) /* Real work is done; log and update stats. */ LogCheckpointEnd(false); + /* Stop reporting progress of the checkpoint. */ + pgstat_progress_end_command(); + /* Reset the process title */ update_checkpoint_display(flags, false, true); @@ -6808,29 +6822,60 @@ static void CheckPointGuts(XLogRecPtr checkPointRedo, int flags) { CheckPointRelationMap(); + + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_REPLI_SLOTS); CheckPointReplicationSlots(); + + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_SNAPSHOTS); CheckPointSnapBuild(); + + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_LOGICAL_REWRITE_MAPPINGS); CheckPointLogicalRewriteHeap(); CheckPointReplicationOrigin(); /* Write out all dirty data in SLRUs and the main buffer pool */ TRACE_POSTGRESQL_BUFFER_CHECKPOINT_START(flags); CheckpointStats.ckpt_write_t = GetCurrentTimestamp(); + + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_CLOG_PAGES); CheckPointCLOG(); + + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_COMMITTS_PAGES); CheckPointCommitTs(); + + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_SUBTRANS_PAGES); CheckPointSUBTRANS(); + + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_MULTIXACT_PAGES); CheckPointMultiXact(); + + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_SLRU_PAGES); CheckPointPredicate(); + + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_BUFFERS); CheckPointBuffers(flags); /* Perform all queued up fsyncs */ TRACE_POSTGRESQL_BUFFER_CHECKPOINT_SYNC_START(); CheckpointStats.ckpt_sync_t = GetCurrentTimestamp(); + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_FILE_SYNC); ProcessSyncRequests(); CheckpointStats.ckpt_sync_end_t = GetCurrentTimestamp(); TRACE_POSTGRESQL_BUFFER_CHECKPOINT_DONE(); /* We deliberately delay 2PC checkpointing as long as possible */ + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_TWO_PHASE); CheckPointTwoPhase(checkPointRedo); } @@ -6977,6 +7022,9 @@ CreateRestartPoint(int flags) MemSet(&CheckpointStats, 0, sizeof(CheckpointStats)); CheckpointStats.ckpt_start_t = GetCurrentTimestamp(); + /* Prepare to report progress of the restartpoint. */ + checkpoint_progress_start(flags); + if (log_checkpoints) LogCheckpointStart(flags, true); @@ -7077,7 +7125,11 @@ CreateRestartPoint(int flags) if (!RecoveryInProgress()) replayTLI = XLogCtl->InsertTimeLineID; + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_OLD_XLOG_RECYCLE); RemoveOldXlogFiles(_logSegNo, RedoRecPtr, endptr, replayTLI); + pgstat_progress_update_param(PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_PHASE_FINALIZE); /* * Make more log segments if needed. (Do this after recycling old log @@ -7098,6 +7150,9 @@ CreateRestartPoint(int flags) /* Real work is done; log and update stats. */ LogCheckpointEnd(true); + /* Stop reporting progress of the restartpoint. */ + pgstat_progress_end_command(); + /* Reset the process title */ update_checkpoint_display(flags, true, true); @@ -9197,3 +9252,27 @@ SetWalWriterSleeping(bool sleeping) XLogCtl->WalWriterSleeping = sleeping; SpinLockRelease(&XLogCtl->info_lck); } + +/* + * Start reporting progress of the checkpoint. + */ +static void +checkpoint_progress_start(int flags) +{ + const int index[] = { + PROGRESS_CHECKPOINT_TIMELINE, + PROGRESS_CHECKPOINT_KIND, + PROGRESS_CHECKPOINT_PHASE, + PROGRESS_CHECKPOINT_START_TIMESTAMP + }; + int64 val[4]; + + pgstat_progress_start_command(PROGRESS_COMMAND_CHECKPOINT, InvalidOid); + + val[0] = XLogCtl->InsertTimeLineID; + val[1] = flags; + val[2] = PROGRESS_CHECKPOINT_PHASE_INIT; + val[3] = CheckpointStats.ckpt_start_t; + + pgstat_progress_update_multi_param(4, index, val); +} \ No newline at end of file diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql index 3cb69b1f87..1c4c8ead9c 100644 --- a/src/backend/catalog/system_views.sql +++ b/src/backend/catalog/system_views.sql @@ -1286,3 +1286,38 @@ CREATE VIEW pg_stat_subscription_workers AS FROM pg_subscription_rel) sr, LATERAL pg_stat_get_subscription_worker(sr.subid, sr.relid) w JOIN pg_subscription s ON (w.subid = s.oid); + +CREATE VIEW pg_stat_progress_checkpoint AS + SELECT + S.pid AS pid, + pg_stat_get_progress_checkpoint_type(S.param1) AS type, + pg_stat_get_progress_checkpoint_kind(S.param2) AS kind, + ( '0/0'::pg_lsn + + ((CASE + WHEN S.param3 < 0 THEN pow(2::numeric, 64::numeric)::numeric + ELSE 0::numeric + END) + + S.param3::numeric) + ) AS start_lsn, + pg_stat_get_progress_checkpoint_start_time(S.param4) AS start_time, + CASE S.param5 WHEN 1 THEN 'initializing' + WHEN 2 THEN 'checkpointing replication slots' + WHEN 3 THEN 'checkpointing snapshots' + WHEN 4 THEN 'checkpointing logical rewrite mappings' + WHEN 5 THEN 'checkpointing commit log pages' + WHEN 6 THEN 'checkpointing commit time stamp pages' + WHEN 7 THEN 'checkpointing subtransaction pages' + WHEN 8 THEN 'checkpointing multixact pages' + WHEN 9 THEN 'checkpointing SLRU pages' + WHEN 10 THEN 'checkpointing buffers' + WHEN 11 THEN 'performing sync requests' + WHEN 12 THEN 'performing two phase checkpoint' + WHEN 13 THEN 'recycling old XLOG files' + WHEN 14 THEN 'Finalizing' + END AS phase, + S.param6 AS total_buffer_writes, + S.param7 AS buffers_processed, + S.param8 AS buffers_written, + S.param9 AS total_file_syncs, + S.param10 AS files_synced + FROM pg_stat_get_progress_info('CHECKPOINT') AS S; diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index f5459c68f8..9663035d7a 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -38,6 +38,7 @@ #include "access/xlogutils.h" #include "catalog/catalog.h" #include "catalog/storage.h" +#include "commands/progress.h" #include "executor/instrument.h" #include "lib/binaryheap.h" #include "miscadmin.h" @@ -2012,6 +2013,8 @@ BufferSync(int flags) WritebackContextInit(&wb_context, &checkpoint_flush_after); TRACE_POSTGRESQL_BUFFER_SYNC_START(NBuffers, num_to_scan); + pgstat_progress_update_param(PROGRESS_CHECKPOINT_BUFFERS_TOTAL, + num_to_scan); /* * Sort buffers that need to be written to reduce the likelihood of random @@ -2129,6 +2132,8 @@ BufferSync(int flags) bufHdr = GetBufferDescriptor(buf_id); num_processed++; + pgstat_progress_update_param(PROGRESS_CHECKPOINT_BUFFERS_PROCESSED, + num_processed); /* * We don't need to acquire the lock here, because we're only looking @@ -2149,6 +2154,8 @@ BufferSync(int flags) TRACE_POSTGRESQL_BUFFER_SYNC_WRITTEN(buf_id); PendingCheckpointerStats.m_buf_written_checkpoints++; num_written++; + pgstat_progress_update_param(PROGRESS_CHECKPOINT_BUFFERS_WRITTEN, + num_written); } } diff --git a/src/backend/storage/sync/sync.c b/src/backend/storage/sync/sync.c index e161d57761..638d3eb781 100644 --- a/src/backend/storage/sync/sync.c +++ b/src/backend/storage/sync/sync.c @@ -23,6 +23,7 @@ #include "access/multixact.h" #include "access/xlog.h" #include "access/xlogutils.h" +#include "commands/progress.h" #include "commands/tablespace.h" #include "miscadmin.h" #include "pgstat.h" @@ -356,6 +357,9 @@ ProcessSyncRequests(void) /* Now scan the hashtable for fsync requests to process */ absorb_counter = FSYNCS_PER_ABSORB; hash_seq_init(&hstat, pendingOps); + pgstat_progress_update_param(PROGRESS_CHECKPOINT_FILES_TOTAL, + hash_get_num_entries(pendingOps)); + while ((entry = (PendingFsyncEntry *) hash_seq_search(&hstat)) != NULL) { int failures; @@ -419,6 +423,8 @@ ProcessSyncRequests(void) longest = elapsed; total_elapsed += elapsed; processed++; + pgstat_progress_update_param(PROGRESS_CHECKPOINT_FILES_SYNCED, + processed); if (log_checkpoints) elog(DEBUG1, "checkpoint sync: number=%d file=%s time=%.3f ms", diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c index 30e8dfa7c1..2ea390a2b6 100644 --- a/src/backend/utils/adt/pgstatfuncs.c +++ b/src/backend/utils/adt/pgstatfuncs.c @@ -494,6 +494,8 @@ pg_stat_get_progress_info(PG_FUNCTION_ARGS) cmdtype = PROGRESS_COMMAND_BASEBACKUP; else if (pg_strcasecmp(cmd, "COPY") == 0) cmdtype = PROGRESS_COMMAND_COPY; + else if (pg_strcasecmp(cmd, "CHECKPOINT") == 0) + cmdtype = PROGRESS_COMMAND_CHECKPOINT; else ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), @@ -2495,3 +2497,50 @@ pg_stat_get_subscription_worker(PG_FUNCTION_ARGS) /* Returns the record as Datum */ PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls))); } + +/* + * Return checkpoint type (either checkpoint or restartpoint). + */ +Datum +pg_stat_get_progress_checkpoint_type(PG_FUNCTION_ARGS) +{ + TimeLineID cur_timeline = (TimeLineID) PG_GETARG_INT64(0); + + if (RecoveryInProgress() || (GetWALInsertionTimeLine() != cur_timeline)) + PG_RETURN_TEXT_P(CStringGetTextDatum("restartpoint")); + else + PG_RETURN_TEXT_P(CStringGetTextDatum("checkpoint")); +} + +/* + * Return checkpoint kind based on the flags set. + */ +Datum +pg_stat_get_progress_checkpoint_kind(PG_FUNCTION_ARGS) +{ + int64 flags = PG_GETARG_INT64(0); + char ckpt_kind[MAXPGPATH]; + + MemSet(ckpt_kind, 0, MAXPGPATH); + snprintf(ckpt_kind, MAXPGPATH, "%s%s%s%s%s%s%s%s%s", + (flags == 0) ? "unknown" : "", + (flags & CHECKPOINT_IS_SHUTDOWN) ? "shutdown " : "", + (flags & CHECKPOINT_END_OF_RECOVERY) ? "end-of-recovery " : "", + (flags & CHECKPOINT_IMMEDIATE) ? "immediate " : "", + (flags & CHECKPOINT_FORCE) ? "force " : "", + (flags & CHECKPOINT_WAIT) ? "wait " : "", + (flags & CHECKPOINT_CAUSE_XLOG) ? "wal " : "", + (flags & CHECKPOINT_CAUSE_TIME) ? "time " : "", + (flags & CHECKPOINT_FLUSH_ALL) ? "flush-all" : ""); + + PG_RETURN_TEXT_P(CStringGetTextDatum(ckpt_kind)); +} + +/* + * Return start time of the checkpoint. + */ +Datum +pg_stat_get_progress_checkpoint_start_time(PG_FUNCTION_ARGS) +{ + PG_RETURN_TIMESTAMPTZ(PG_GETARG_INT64(0)); +} \ No newline at end of file diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat index 7f1ee97f55..06a84e2488 100644 --- a/src/include/catalog/pg_proc.dat +++ b/src/include/catalog/pg_proc.dat @@ -5353,6 +5353,18 @@ proargmodes => '{i,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o,o}', proargnames => '{cmdtype,pid,datid,relid,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20}', prosrc => 'pg_stat_get_progress_info' }, +{ oid => '560', descr => 'return checkpoint type', + proname => 'pg_stat_get_progress_checkpoint_type', provolatile => 'i', + prorettype => 'text', proargtypes => 'int8', + prosrc => 'pg_stat_get_progress_checkpoint_type' }, +{ oid => '561', descr => 'return checkpoint kind', + proname => 'pg_stat_get_progress_checkpoint_kind', provolatile => 'i', + prorettype => 'text', proargtypes => 'int8', + prosrc => 'pg_stat_get_progress_checkpoint_kind' }, +{ oid => '562', descr => 'return elapsed time of the checkpoint', + proname => 'pg_stat_get_progress_checkpoint_start_time', provolatile => 'i', + prorettype => 'timestamptz', proargtypes => 'int8', + prosrc => 'pg_stat_get_progress_checkpoint_start_time' }, { oid => '3099', descr => 'statistics: information about currently active replication', proname => 'pg_stat_get_wal_senders', prorows => '10', proisstrict => 'f', diff --git a/src/include/commands/progress.h b/src/include/commands/progress.h index a28938caf4..19e9e93072 100644 --- a/src/include/commands/progress.h +++ b/src/include/commands/progress.h @@ -151,4 +151,32 @@ #define PROGRESS_COPY_TYPE_PIPE 3 #define PROGRESS_COPY_TYPE_CALLBACK 4 +/* Progress parameters for checkpoint */ +#define PROGRESS_CHECKPOINT_TIMELINE 0 +#define PROGRESS_CHECKPOINT_KIND 1 +#define PROGRESS_CHECKPOINT_LSN 2 +#define PROGRESS_CHECKPOINT_START_TIMESTAMP 3 +#define PROGRESS_CHECKPOINT_PHASE 4 +#define PROGRESS_CHECKPOINT_BUFFERS_TOTAL 5 +#define PROGRESS_CHECKPOINT_BUFFERS_PROCESSED 6 +#define PROGRESS_CHECKPOINT_BUFFERS_WRITTEN 7 +#define PROGRESS_CHECKPOINT_FILES_TOTAL 8 +#define PROGRESS_CHECKPOINT_FILES_SYNCED 9 + +/* Phases of checkpoint (as advertised via PROGRESS_CHECKPOINT_PHASE) */ +#define PROGRESS_CHECKPOINT_PHASE_INIT 1 +#define PROGRESS_CHECKPOINT_PHASE_REPLI_SLOTS 2 +#define PROGRESS_CHECKPOINT_PHASE_SNAPSHOTS 3 +#define PROGRESS_CHECKPOINT_PHASE_LOGICAL_REWRITE_MAPPINGS 4 +#define PROGRESS_CHECKPOINT_PHASE_CLOG_PAGES 5 +#define PROGRESS_CHECKPOINT_PHASE_COMMITTS_PAGES 6 +#define PROGRESS_CHECKPOINT_PHASE_SUBTRANS_PAGES 7 +#define PROGRESS_CHECKPOINT_PHASE_MULTIXACT_PAGES 8 +#define PROGRESS_CHECKPOINT_PHASE_SLRU_PAGES 9 +#define PROGRESS_CHECKPOINT_PHASE_BUFFERS 10 +#define PROGRESS_CHECKPOINT_PHASE_FILE_SYNC 11 +#define PROGRESS_CHECKPOINT_PHASE_TWO_PHASE 12 +#define PROGRESS_CHECKPOINT_PHASE_OLD_XLOG_RECYCLE 13 +#define PROGRESS_CHECKPOINT_PHASE_FINALIZE 14 + #endif diff --git a/src/include/utils/backend_progress.h b/src/include/utils/backend_progress.h index 47bf8029b0..02d51fb948 100644 --- a/src/include/utils/backend_progress.h +++ b/src/include/utils/backend_progress.h @@ -27,7 +27,8 @@ typedef enum ProgressCommandType PROGRESS_COMMAND_CLUSTER, PROGRESS_COMMAND_CREATE_INDEX, PROGRESS_COMMAND_BASEBACKUP, - PROGRESS_COMMAND_COPY + PROGRESS_COMMAND_COPY, + PROGRESS_COMMAND_CHECKPOINT } ProgressCommandType; #define PGSTAT_NUM_PROGRESS_PARAM 20 diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out index 1420288d67..e3024975d9 100644 --- a/src/test/regress/expected/rules.out +++ b/src/test/regress/expected/rules.out @@ -1897,6 +1897,38 @@ pg_stat_progress_basebackup| SELECT s.pid, s.param4 AS tablespaces_total, s.param5 AS tablespaces_streamed FROM pg_stat_get_progress_info('BASEBACKUP'::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); +pg_stat_progress_checkpoint| SELECT s.pid, + pg_stat_get_progress_checkpoint_type(s.param1) AS type, + pg_stat_get_progress_checkpoint_kind(s.param2) AS kind, + ('0/0'::pg_lsn + ( + CASE + WHEN (s.param3 < 0) THEN pow((2)::numeric, (64)::numeric) + ELSE (0)::numeric + END + (s.param3)::numeric)) AS start_lsn, + pg_stat_get_progress_checkpoint_start_time(s.param4) AS start_time, + CASE s.param5 + WHEN 1 THEN 'initializing'::text + WHEN 2 THEN 'checkpointing replication slots'::text + WHEN 3 THEN 'checkpointing snapshots'::text + WHEN 4 THEN 'checkpointing logical rewrite mappings'::text + WHEN 5 THEN 'checkpointing commit log pages'::text + WHEN 6 THEN 'checkpointing commit time stamp pages'::text + WHEN 7 THEN 'checkpointing subtransaction pages'::text + WHEN 8 THEN 'checkpointing multixact pages'::text + WHEN 9 THEN 'checkpointing SLRU pages'::text + WHEN 10 THEN 'checkpointing buffers'::text + WHEN 11 THEN 'performing sync requests'::text + WHEN 12 THEN 'performing two phase checkpoint'::text + WHEN 13 THEN 'recycling old XLOG files'::text + WHEN 14 THEN 'Finalizing'::text + ELSE NULL::text + END AS phase, + s.param6 AS total_buffer_writes, + s.param7 AS buffers_processed, + s.param8 AS buffers_written, + s.param9 AS total_file_syncs, + s.param10 AS files_synced + FROM pg_stat_get_progress_info('CHECKPOINT'::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); pg_stat_progress_cluster| SELECT s.pid, s.datid, d.datname, -- 2.25.1