v31 attached I've also addressed failing test mentioned by Andres in [1] On Fri, Sep 30, 2022 at 7:18 PM Lukas Fittl <lu...@fittl.com> wrote: > > On Tue, Sep 27, 2022 at 11:20 AM Melanie Plageman <melanieplage...@gmail.com> > wrote: > > First of all, I'm excited about this patch, and I think it will be a big help > to understand better which part of Postgres is producing I/O (and why). >
Thanks! I'm happy to hear that. > I've paired up with Maciek (CCed) on a review of this patch and had a few > comments, focused on the user experience: > Thanks for taking the time to review! > The term "strategy" as an "io_context" is hard to understand, as its not a > concept an end-user / DBA would be familiar with. Since this comes from > BufferAccessStrategyType (i.e. anything not NULL/BAS_NORMAL is treated as > "strategy"), maybe we could instead split this out into the individual > strategy types? i.e. making "strategy" three different I/O contexts instead: > "shared_bulkread", "shared_bulkwrite" and "shared_vacuum", retaining "shared" > to mean NULL / BAS_NORMAL. I have split strategy out into "vacuum", "bulkread", and "bulkwrite". I thought it was less clear with shared as a prefix. If we were to have BufferAccessStrategies in the future which acquire local buffers (for example), we could start prefixing the columns to differentiate. This opened up some new questions about which BufferAccessStrategies will be employed by which BackendTypes and which IOOps will be valid in a given BufferAccessStrategy. I've excluded IOCONTEXT_BULKREAD and IOCONTEXT_BULKWRITE for autovacuum worker -- though those may not be inherently invalid, they seem not to be done now and added extra rows to the view. I've also disallowed IOOP_EXTEND for IOCONTEXT_BULKREAD. > Separately, could we also track buffer hits without incurring extra overhead? > (not just allocs and reads) -- Whilst we already have shared read and hit > counters in a few other places, this would help make the common "What's my > cache hit ratio" question more accurate to answer in the presence of > different shared buffer access strategies. Tracking hits could also help for > local buffers (e.g. to tune temp_buffers based on seeing a low cache hit > ratio). I've started tracking hits and added "hit" to the view. I added IOOP_HIT and IOOP_ACQUIRE to those IOOps disallowed for checkpointer and bgwriter. I have added tests for hit, but I'm not sure I can keep them. It seems like they might fail if the blocks are evicted between the first and second time I try to read them. > Additionally, some minor notes: > > - Since the stats are counting blocks, it would make sense to prefix the view > columns with "blks_", and word them in the past tense (to match current > style), i.e. "blks_written", "blks_read", "blks_extended", "blks_fsynced" > (realistically one would combine this new view with other data e.g. from > pg_stat_database or pg_stat_statements, which all use the "blks_" prefix, and > stop using pg_stat_bgwriter for this which does not use such a prefix) I have changed the column names to be in the past tense. There are no columns equivalent to "dirty" or "misses" from the other views containing information on buffer hits/block reads/writes/etc. I'm not sure whether or not those make sense in this context. Because we want to add non-block-oriented IO in the future (like temporary file IO) to this view and want to use the same "read", "written", "extended" columns, I would prefer not to prefix the columns with "blks_". I have added a column "unit" which would contain the unit in which read, written, and extended are in. Unfortunately, fsyncs are not per block, so "unit" doesn't really work for this. I documented this. The most correct thing to do to accommodate block-oriented and non-block-oriented IO would be to specify all the values in bytes. However, I would like this view to be usable visually (as opposed to just in scripts and by tools). The only current value of unit is "block_size" which could potentially be combined with the value of the GUC to get bytes. I've hard-coded the string "block_size" into the view generation function pg_stat_get_io(), so, if this idea makes sense, perhaps I should do something better there. > - "alloc" as a name doesn't seem intuitive (and it may be confused with > memory allocations) - whilst this is already named this way in > pg_stat_bgwriter, it feels like this is an opportunity to eventually > deprecate the column there and make this easier to understand - specifically, > maybe we can clarify that this means buffer *acquisitions*? (either by > renaming the field to "blks_acquired", or clarifying in the documentation) I have renamed it to acquired. It doesn't overlap completely with buffers_alloc in pg_stat_bgwriter, so I didn't mention that in docs. > - Assuming we think this view could realistically cover all I/O produced by > Postgres in the future (thus warranting the name "pg_stat_io"), it may be > best to have an explicit list of things that are not currently tracked in the > documentation, to reduce user confusion (i.e. WAL writes are not tracked, > temporary files are not tracked, and some forms of direct writes are not > tracked, e.g. when a table moves to a different tablespace) I have added this to the docs. The list is not exhaustive, so I would love to get feedback on if there are other specific examples of IO which is using smgr* directly that users will wonder about and I should call out. > - In the view documentation, it would be good to explain the different values > for "io_strategy" (and what they mean) I have added this and would love feedback on my docs additions. > - Overall it would be helpful if we had a dedicated documentation page on I/O > statistics that's linked from the pg_stat_io view description, and explains > how the I/O statistics tie into the various concepts of shared buffers / > buffer access strategies / etc (and what is not tracked today) I haven't done this yet. How specific were you thinking -- like interpretations of all the combinations and what to do with what you see? Like you should run pg_prewarm if you see X? Specific checkpointer or bgwriter GUCs to change? Or just links to other docs pages on recommended tunings? Were you imagining the other IO statistics views (like pg_statio_all_tables and pg_stat_database) also being included in this page? Like would it be a comprehensive guide to IO statistics and what their significance/purposes are? - Melanie [1] https://www.postgresql.org/message-id/20221002172404.xyzhftbedh4zpio2%40awork3.anarazel.de
From 0ee5cda16066edbbe0b992cae7272c9e2671d1a7 Mon Sep 17 00:00:00 2001 From: Melanie Plageman <melanieplage...@gmail.com> Date: Thu, 6 Oct 2022 12:23:38 -0400 Subject: [PATCH v31 2/3] Aggregate IO operation stats per BackendType Stats on IOOps for all IOContexts for a backend are tracked locally. Add functionality for backends to flush these stats to shared memory and accumulate them with those from all other backends, exited and live. Also add reset and snapshot functions used by cumulative stats system for management of these statistics. The aggregated stats in shared memory could be extended in the future with per-backend stats -- useful for per connection IO statistics and monitoring. Some BackendTypes will not flush their pending statistics at regular intervals and explicitly call pgstat_flush_io_ops() during the course of normal operations to flush their backend-local IO operation statistics to shared memory in a timely manner. Because not all BackendType, IOOp, IOContext combinations are valid, the validity of the stats is checked before flushing pending stats and before reading in the existing stats file to shared memory. Author: Melanie Plageman <melanieplage...@gmail.com> Reviewed-by: Andres Freund <and...@anarazel.de> Reviewed-by: Justin Pryzby <pry...@telsasoft.com> Reviewed-by: Kyotaro Horiguchi <horikyota....@gmail.com> Reviewed-by: Maciek Sakrejda <m.sakre...@gmail.com> Reviewed-by: Lukas Fittl <lu...@fittl.com> Discussion: https://www.postgresql.org/message-id/flat/20200124195226.lth52iydq2n2uilq%40alap3.anarazel.de --- doc/src/sgml/monitoring.sgml | 2 + src/backend/utils/activity/pgstat.c | 35 ++++ src/backend/utils/activity/pgstat_bgwriter.c | 7 +- .../utils/activity/pgstat_checkpointer.c | 7 +- src/backend/utils/activity/pgstat_io_ops.c | 157 ++++++++++++++++++ src/backend/utils/activity/pgstat_relation.c | 15 +- src/backend/utils/activity/pgstat_shmem.c | 4 + src/backend/utils/activity/pgstat_wal.c | 4 +- src/backend/utils/adt/pgstatfuncs.c | 4 +- src/include/miscadmin.h | 2 + src/include/pgstat.h | 83 ++++++++- src/include/utils/pgstat_internal.h | 37 +++++ src/tools/pgindent/typedefs.list | 3 + 13 files changed, 353 insertions(+), 7 deletions(-) diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml index 342b20ebeb..14dfd650f8 100644 --- a/doc/src/sgml/monitoring.sgml +++ b/doc/src/sgml/monitoring.sgml @@ -5360,6 +5360,8 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i the <structname>pg_stat_bgwriter</structname> view, <literal>archiver</literal> to reset all the counters shown in the <structname>pg_stat_archiver</structname> view, + <literal>io</literal> to reset all the counters shown in the + <structname>pg_stat_io</structname> view, <literal>wal</literal> to reset all the counters shown in the <structname>pg_stat_wal</structname> view or <literal>recovery_prefetch</literal> to reset all the counters shown diff --git a/src/backend/utils/activity/pgstat.c b/src/backend/utils/activity/pgstat.c index 609f0b1ad8..e66dde0ea5 100644 --- a/src/backend/utils/activity/pgstat.c +++ b/src/backend/utils/activity/pgstat.c @@ -359,6 +359,15 @@ static const PgStat_KindInfo pgstat_kind_infos[PGSTAT_NUM_KINDS] = { .snapshot_cb = pgstat_checkpointer_snapshot_cb, }, + [PGSTAT_KIND_IOOPS] = { + .name = "io_ops", + + .fixed_amount = true, + + .reset_all_cb = pgstat_io_ops_reset_all_cb, + .snapshot_cb = pgstat_io_ops_snapshot_cb, + }, + [PGSTAT_KIND_SLRU] = { .name = "slru", @@ -582,6 +591,7 @@ pgstat_report_stat(bool force) /* Don't expend a clock check if nothing to do */ if (dlist_is_empty(&pgStatPending) && + !have_ioopstats && !have_slrustats && !pgstat_have_pending_wal()) { @@ -628,6 +638,9 @@ pgstat_report_stat(bool force) /* flush database / relation / function / ... stats */ partial_flush |= pgstat_flush_pending_entries(nowait); + /* flush IO Operations stats */ + partial_flush |= pgstat_flush_io_ops(nowait); + /* flush wal stats */ partial_flush |= pgstat_flush_wal(nowait); @@ -1321,6 +1334,14 @@ pgstat_write_statsfile(void) pgstat_build_snapshot_fixed(PGSTAT_KIND_CHECKPOINTER); write_chunk_s(fpout, &pgStatLocal.snapshot.checkpointer); + /* + * Write IO Operations stats struct + */ + pgstat_build_snapshot_fixed(PGSTAT_KIND_IOOPS); + write_chunk_s(fpout, &pgStatLocal.snapshot.io_ops.stat_reset_timestamp); + for (int i = 0; i < BACKEND_NUM_TYPES; i++) + write_chunk_s(fpout, &pgStatLocal.snapshot.io_ops.stats[i]); + /* * Write SLRU stats struct */ @@ -1495,6 +1516,20 @@ pgstat_read_statsfile(void) if (!read_chunk_s(fpin, &shmem->checkpointer.stats)) goto error; + /* + * Read IO Operations stats struct + */ + if (!read_chunk_s(fpin, &shmem->io_ops.stat_reset_timestamp)) + goto error; + + for (int bktype = 0; bktype < BACKEND_NUM_TYPES; bktype++) + { + pgstat_backend_io_stats_assert_well_formed(shmem->io_ops.stats[bktype].data, + bktype); + if (!read_chunk_s(fpin, &shmem->io_ops.stats[bktype].data)) + goto error; + } + /* * Read SLRU stats struct */ diff --git a/src/backend/utils/activity/pgstat_bgwriter.c b/src/backend/utils/activity/pgstat_bgwriter.c index fbb1edc527..3d7f90a1b7 100644 --- a/src/backend/utils/activity/pgstat_bgwriter.c +++ b/src/backend/utils/activity/pgstat_bgwriter.c @@ -24,7 +24,7 @@ PgStat_BgWriterStats PendingBgWriterStats = {0}; /* - * Report bgwriter statistics + * Report bgwriter and IO Operation statistics */ void pgstat_report_bgwriter(void) @@ -56,6 +56,11 @@ pgstat_report_bgwriter(void) * Clear out the statistics buffer, so it can be re-used. */ MemSet(&PendingBgWriterStats, 0, sizeof(PendingBgWriterStats)); + + /* + * Report IO Operations statistics + */ + pgstat_flush_io_ops(false); } /* diff --git a/src/backend/utils/activity/pgstat_checkpointer.c b/src/backend/utils/activity/pgstat_checkpointer.c index af8d513e7b..cfcf127210 100644 --- a/src/backend/utils/activity/pgstat_checkpointer.c +++ b/src/backend/utils/activity/pgstat_checkpointer.c @@ -24,7 +24,7 @@ PgStat_CheckpointerStats PendingCheckpointerStats = {0}; /* - * Report checkpointer statistics + * Report checkpointer and IO Operation statistics */ void pgstat_report_checkpointer(void) @@ -62,6 +62,11 @@ pgstat_report_checkpointer(void) * Clear out the statistics buffer, so it can be re-used. */ MemSet(&PendingCheckpointerStats, 0, sizeof(PendingCheckpointerStats)); + + /* + * Report IO Operation statistics + */ + pgstat_flush_io_ops(false); } /* diff --git a/src/backend/utils/activity/pgstat_io_ops.c b/src/backend/utils/activity/pgstat_io_ops.c index cea46322a7..86d403fe55 100644 --- a/src/backend/utils/activity/pgstat_io_ops.c +++ b/src/backend/utils/activity/pgstat_io_ops.c @@ -20,6 +20,42 @@ #include "utils/pgstat_internal.h" static PgStat_IOContextOps pending_IOOpStats; +bool have_ioopstats = false; + + +/* + * Helper function to accumulate source PgStat_IOOpCounters into target + * PgStat_IOOpCounters. If either of the passed-in PgStat_IOOpCounters are + * members of PgStatShared_IOContextOps, the caller is responsible for ensuring + * that the appropriate lock is held. + */ +static void +pgstat_accum_io_op(PgStat_IOOpCounters *target, PgStat_IOOpCounters *source, IOOp io_op) +{ + switch (io_op) + { + case IOOP_ACQUIRE: + target->acquires += source->acquires; + return; + case IOOP_EXTEND: + target->extends += source->extends; + return; + case IOOP_FSYNC: + target->fsyncs += source->fsyncs; + return; + case IOOP_HIT: + target->hits += source->hits; + return; + case IOOP_READ: + target->reads += source->reads; + return; + case IOOP_WRITE: + target->writes += source->writes; + return; + } + + elog(ERROR, "unrecognized IOOp value: %d", io_op); +} void pgstat_count_io_op(IOOp io_op, IOContext io_context) @@ -54,6 +90,77 @@ pgstat_count_io_op(IOOp io_op, IOContext io_context) break; } + have_ioopstats = true; +} + +PgStat_BackendIOContextOps * +pgstat_fetch_backend_io_context_ops(void) +{ + pgstat_snapshot_fixed(PGSTAT_KIND_IOOPS); + + return &pgStatLocal.snapshot.io_ops; +} + +/* + * Flush out locally pending IO Operation statistics entries + * + * If no stats have been recorded, this function returns false. + * + * If nowait is true, this function returns true if the lock could not be + * acquired. Otherwise, return false. + */ +bool +pgstat_flush_io_ops(bool nowait) +{ + PgStatShared_IOContextOps *type_shstats; + bool expect_backend_stats = true; + + if (!have_ioopstats) + return false; + + type_shstats = + &pgStatLocal.shmem->io_ops.stats[MyBackendType]; + + if (!nowait) + LWLockAcquire(&type_shstats->lock, LW_EXCLUSIVE); + else if (!LWLockConditionalAcquire(&type_shstats->lock, LW_EXCLUSIVE)) + return true; + + expect_backend_stats = pgstat_io_op_stats_collected(MyBackendType); + + for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++) + { + PgStat_IOOpCounters *sharedent = &type_shstats->data[io_context]; + PgStat_IOOpCounters *pendingent = &pending_IOOpStats.data[io_context]; + + if (!expect_backend_stats || + !pgstat_bktype_io_context_valid(MyBackendType, io_context)) + { + pgstat_io_context_ops_assert_zero(sharedent); + pgstat_io_context_ops_assert_zero(pendingent); + continue; + } + + for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++) + { + if (!(pgstat_io_op_valid(MyBackendType, io_context, io_op))) + { + pgstat_io_op_assert_zero(sharedent, io_op); + pgstat_io_op_assert_zero(pendingent, io_op); + continue; + } + + pgstat_accum_io_op(sharedent, pendingent, io_op); + } + } + + LWLockRelease(&type_shstats->lock); + + memset(&pending_IOOpStats, 0, sizeof(pending_IOOpStats)); + + have_ioopstats = false; + + return false; } const char * @@ -98,6 +205,56 @@ pgstat_io_op_desc(IOOp io_op) elog(ERROR, "unrecognized IOOp value: %d", io_op); } +void +pgstat_io_ops_reset_all_cb(TimestampTz ts) +{ + PgStatShared_BackendIOContextOps *backends_stats_shmem = &pgStatLocal.shmem->io_ops; + + for (int i = 0; i < BACKEND_NUM_TYPES; i++) + { + PgStatShared_IOContextOps *stats_shmem = &backends_stats_shmem->stats[i]; + + LWLockAcquire(&stats_shmem->lock, LW_EXCLUSIVE); + + /* + * Use the lock in the first BackendType's PgStat_IOContextOps to + * protect the reset timestamp as well. + */ + if (i == 0) + backends_stats_shmem->stat_reset_timestamp = ts; + + memset(stats_shmem->data, 0, sizeof(stats_shmem->data)); + LWLockRelease(&stats_shmem->lock); + } +} + +void +pgstat_io_ops_snapshot_cb(void) +{ + PgStatShared_BackendIOContextOps *backends_stats_shmem = &pgStatLocal.shmem->io_ops; + PgStat_BackendIOContextOps *backends_stats_snap = &pgStatLocal.snapshot.io_ops; + + for (int i = 0; i < BACKEND_NUM_TYPES; i++) + { + PgStatShared_IOContextOps *stats_shmem = &backends_stats_shmem->stats[i]; + PgStat_IOContextOps *stats_snap = &backends_stats_snap->stats[i]; + + LWLockAcquire(&stats_shmem->lock, LW_SHARED); + + /* + * Use the lock in the first BackendType's PgStat_IOContextOps to + * protect the reset timestamp as well. + */ + if (i == 0) + backends_stats_snap->stat_reset_timestamp = + backends_stats_shmem->stat_reset_timestamp; + + memcpy(stats_snap->data, stats_shmem->data, sizeof(stats_shmem->data)); + LWLockRelease(&stats_shmem->lock); + } + +} + /* * IO Operation statistics are not collected for all BackendTypes. * diff --git a/src/backend/utils/activity/pgstat_relation.c b/src/backend/utils/activity/pgstat_relation.c index a846d9ffb6..7a2fd1ccf9 100644 --- a/src/backend/utils/activity/pgstat_relation.c +++ b/src/backend/utils/activity/pgstat_relation.c @@ -205,7 +205,7 @@ pgstat_drop_relation(Relation rel) } /* - * Report that the table was just vacuumed. + * Report that the table was just vacuumed and flush IO Operation statistics. */ void pgstat_report_vacuum(Oid tableoid, bool shared, @@ -257,10 +257,18 @@ pgstat_report_vacuum(Oid tableoid, bool shared, } pgstat_unlock_entry(entry_ref); + + /* + * Flush IO Operations statistics now. pgstat_report_stat() will flush IO + * Operation stats, however this will not be called after an entire + * autovacuum cycle is done -- which will likely vacuum many relations -- + * or until the VACUUM command has processed all tables and committed. + */ + pgstat_flush_io_ops(false); } /* - * Report that the table was just analyzed. + * Report that the table was just analyzed and flush IO Operation statistics. * * Caller must provide new live- and dead-tuples estimates, as well as a * flag indicating whether to reset the changes_since_analyze counter. @@ -340,6 +348,9 @@ pgstat_report_analyze(Relation rel, } pgstat_unlock_entry(entry_ref); + + /* see pgstat_report_vacuum() */ + pgstat_flush_io_ops(false); } /* diff --git a/src/backend/utils/activity/pgstat_shmem.c b/src/backend/utils/activity/pgstat_shmem.c index 9a4f037959..275a7be166 100644 --- a/src/backend/utils/activity/pgstat_shmem.c +++ b/src/backend/utils/activity/pgstat_shmem.c @@ -202,6 +202,10 @@ StatsShmemInit(void) LWLockInitialize(&ctl->checkpointer.lock, LWTRANCHE_PGSTATS_DATA); LWLockInitialize(&ctl->slru.lock, LWTRANCHE_PGSTATS_DATA); LWLockInitialize(&ctl->wal.lock, LWTRANCHE_PGSTATS_DATA); + + for (int i = 0; i < BACKEND_NUM_TYPES; i++) + LWLockInitialize(&ctl->io_ops.stats[i].lock, + LWTRANCHE_PGSTATS_DATA); } else { diff --git a/src/backend/utils/activity/pgstat_wal.c b/src/backend/utils/activity/pgstat_wal.c index 5a878bd115..9cac407b42 100644 --- a/src/backend/utils/activity/pgstat_wal.c +++ b/src/backend/utils/activity/pgstat_wal.c @@ -34,7 +34,7 @@ static WalUsage prevWalUsage; /* * Calculate how much WAL usage counters have increased and update - * shared statistics. + * shared WAL and IO Operation statistics. * * Must be called by processes that generate WAL, that do not call * pgstat_report_stat(), like walwriter. @@ -43,6 +43,8 @@ void pgstat_report_wal(bool force) { pgstat_flush_wal(force); + + pgstat_flush_io_ops(force); } /* diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c index eadd8464ff..edd73e5c25 100644 --- a/src/backend/utils/adt/pgstatfuncs.c +++ b/src/backend/utils/adt/pgstatfuncs.c @@ -2071,6 +2071,8 @@ pg_stat_reset_shared(PG_FUNCTION_ARGS) pgstat_reset_of_kind(PGSTAT_KIND_BGWRITER); pgstat_reset_of_kind(PGSTAT_KIND_CHECKPOINTER); } + else if (strcmp(target, "io") == 0) + pgstat_reset_of_kind(PGSTAT_KIND_IOOPS); else if (strcmp(target, "recovery_prefetch") == 0) XLogPrefetchResetStats(); else if (strcmp(target, "wal") == 0) @@ -2079,7 +2081,7 @@ pg_stat_reset_shared(PG_FUNCTION_ARGS) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("unrecognized reset target: \"%s\"", target), - errhint("Target must be \"archiver\", \"bgwriter\", \"recovery_prefetch\", or \"wal\"."))); + errhint("Target must be \"archiver\", \"io\", \"bgwriter\", \"recovery_prefetch\", or \"wal\"."))); PG_RETURN_VOID(); } diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h index e7ebea4ff4..bf97162e83 100644 --- a/src/include/miscadmin.h +++ b/src/include/miscadmin.h @@ -331,6 +331,8 @@ typedef enum BackendType B_WAL_WRITER, } BackendType; +#define BACKEND_NUM_TYPES B_WAL_WRITER + 1 + extern PGDLLIMPORT BackendType MyBackendType; extern const char *GetBackendTypeDesc(BackendType backendType); diff --git a/src/include/pgstat.h b/src/include/pgstat.h index 472e0def97..0d3d5e28a1 100644 --- a/src/include/pgstat.h +++ b/src/include/pgstat.h @@ -49,6 +49,7 @@ typedef enum PgStat_Kind PGSTAT_KIND_ARCHIVER, PGSTAT_KIND_BGWRITER, PGSTAT_KIND_CHECKPOINTER, + PGSTAT_KIND_IOOPS, PGSTAT_KIND_SLRU, PGSTAT_KIND_WAL, } PgStat_Kind; @@ -243,7 +244,7 @@ typedef struct PgStat_TableXactStatus * ------------------------------------------------------------ */ -#define PGSTAT_FILE_FORMAT_ID 0x01A5BCA7 +#define PGSTAT_FILE_FORMAT_ID 0x01A5BCA8 typedef struct PgStat_ArchiverStats { @@ -319,6 +320,12 @@ typedef struct PgStat_IOContextOps PgStat_IOOpCounters data[IOCONTEXT_NUM_TYPES]; } PgStat_IOContextOps; +typedef struct PgStat_BackendIOContextOps +{ + TimestampTz stat_reset_timestamp; + PgStat_IOContextOps stats[BACKEND_NUM_TYPES]; +} PgStat_BackendIOContextOps; + typedef struct PgStat_StatDBEntry { PgStat_Counter n_xact_commit; @@ -501,6 +508,7 @@ extern PgStat_CheckpointerStats *pgstat_fetch_stat_checkpointer(void); */ extern void pgstat_count_io_op(IOOp io_op, IOContext io_context); +extern PgStat_BackendIOContextOps *pgstat_fetch_backend_io_context_ops(void); extern const char *pgstat_io_context_desc(IOContext io_context); extern const char *pgstat_io_op_desc(IOOp io_op); @@ -512,6 +520,79 @@ extern bool pgstat_expect_io_op(BackendType bktype, IOContext io_context, IOOp i /* IO stats translation function in freelist.c */ extern IOContext IOContextForStrategy(BufferAccessStrategy bas); +/* + * Functions to assert that invalid IO Operation counters are zero. + */ +static inline void +pgstat_io_context_ops_assert_zero(PgStat_IOOpCounters *counters) +{ + Assert(counters->acquires == 0 && counters->extends == 0 && + counters->fsyncs == 0 && counters->reads == 0 && + counters->writes == 0); +} + +static inline void +pgstat_io_op_assert_zero(PgStat_IOOpCounters *counters, IOOp io_op) +{ + switch (io_op) + { + case IOOP_ACQUIRE: + Assert(counters->acquires == 0); + return; + case IOOP_EXTEND: + Assert(counters->extends == 0); + return; + case IOOP_FSYNC: + Assert(counters->fsyncs == 0); + return; + case IOOP_HIT: + Assert(counters->hits == 0); + return; + case IOOP_READ: + Assert(counters->reads == 0); + return; + case IOOP_WRITE: + Assert(counters->writes == 0); + return; + } + + /* Should not reach here */ + Assert(false); +} + +/* + * Assert that stats have not been counted for any combination of IOContext and + * IOOp which are not valid for the passed-in BackendType. The passed-in array + * of PgStat_IOOpCounters must contain stats from the BackendType specified by + * the second parameter. Caller is responsible for any locking if the passed-in + * array of PgStat_IOOpCounters is a member of PgStatShared_IOContextOps. + */ +static inline void +pgstat_backend_io_stats_assert_well_formed(PgStat_IOOpCounters + backend_io_context_ops[IOCONTEXT_NUM_TYPES], BackendType bktype) +{ + bool expect_backend_stats = true; + + if (!pgstat_io_op_stats_collected(bktype)) + expect_backend_stats = false; + + for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++) + { + if (!expect_backend_stats || + !pgstat_bktype_io_context_valid(bktype, io_context)) + { + pgstat_io_context_ops_assert_zero(&backend_io_context_ops[io_context]); + continue; + } + + for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++) + { + if (!pgstat_io_op_valid(bktype, io_context, io_op)) + pgstat_io_op_assert_zero(&backend_io_context_ops[io_context], + io_op); + } + } +} /* diff --git a/src/include/utils/pgstat_internal.h b/src/include/utils/pgstat_internal.h index 40a3602855..95f19cae99 100644 --- a/src/include/utils/pgstat_internal.h +++ b/src/include/utils/pgstat_internal.h @@ -329,6 +329,26 @@ typedef struct PgStatShared_Checkpointer PgStat_CheckpointerStats reset_offset; } PgStatShared_Checkpointer; +typedef struct PgStatShared_IOContextOps +{ + /* + * lock protects ->data + * If this PgStatShared_IOContextOps is + * PgStatShared_BackendIOContextOps->stats[0], lock also protects + * PgStatShared_BackendIOContextOps->stat_reset_timestamp. + */ + LWLock lock; + PgStat_IOOpCounters data[IOCONTEXT_NUM_TYPES]; +} PgStatShared_IOContextOps; + +typedef struct PgStatShared_BackendIOContextOps +{ + /* ->stats_reset_timestamp is protected by ->stats[0].lock */ + TimestampTz stat_reset_timestamp; + PgStatShared_IOContextOps stats[BACKEND_NUM_TYPES]; +} PgStatShared_BackendIOContextOps; + + typedef struct PgStatShared_SLRU { /* lock protects ->stats */ @@ -419,6 +439,7 @@ typedef struct PgStat_ShmemControl PgStatShared_Archiver archiver; PgStatShared_BgWriter bgwriter; PgStatShared_Checkpointer checkpointer; + PgStatShared_BackendIOContextOps io_ops; PgStatShared_SLRU slru; PgStatShared_Wal wal; } PgStat_ShmemControl; @@ -442,6 +463,8 @@ typedef struct PgStat_Snapshot PgStat_CheckpointerStats checkpointer; + PgStat_BackendIOContextOps io_ops; + PgStat_SLRUStats slru[SLRU_NUM_ELEMENTS]; PgStat_WalStats wal; @@ -549,6 +572,15 @@ extern void pgstat_database_reset_timestamp_cb(PgStatShared_Common *header, Time extern bool pgstat_function_flush_cb(PgStat_EntryRef *entry_ref, bool nowait); +/* + * Functions in pgstat_io_ops.c + */ + +extern void pgstat_io_ops_reset_all_cb(TimestampTz ts); +extern void pgstat_io_ops_snapshot_cb(void); +extern bool pgstat_flush_io_ops(bool nowait); + + /* * Functions in pgstat_relation.c */ @@ -641,6 +673,11 @@ extern void pgstat_create_transactional(PgStat_Kind kind, Oid dboid, Oid objoid) extern PGDLLIMPORT PgStat_LocalState pgStatLocal; +/* + * Variables in pgstat_io_ops.c + */ + +extern PGDLLIMPORT bool have_ioopstats; /* * Variables in pgstat_slru.c diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 67218ec6f2..33c9362257 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2005,12 +2005,14 @@ PgFdwRelationInfo PgFdwScanState PgIfAddrCallback PgStatShared_Archiver +PgStatShared_BackendIOContextOps PgStatShared_BgWriter PgStatShared_Checkpointer PgStatShared_Common PgStatShared_Database PgStatShared_Function PgStatShared_HashEntry +PgStatShared_IOContextOps PgStatShared_Relation PgStatShared_ReplSlot PgStatShared_SLRU @@ -2018,6 +2020,7 @@ PgStatShared_Subscription PgStatShared_Wal PgStat_ArchiverStats PgStat_BackendFunctionEntry +PgStat_BackendIOContextOps PgStat_BackendSubEntry PgStat_BgWriterStats PgStat_CheckpointerStats -- 2.34.1
From 275222925d4d207749c81982467dfc742a5c1d3e Mon Sep 17 00:00:00 2001 From: Melanie Plageman <melanieplage...@gmail.com> Date: Thu, 6 Oct 2022 12:24:42 -0400 Subject: [PATCH v31 3/3] Add system view tracking IO ops per backend type Add pg_stat_io, a system view which tracks the number of IOOps (acquires, extends, fsyncs, hits, reads, and writes) done through each IOContext (shared buffers, local buffers, and buffers reserved by a BufferAccessStrategy) by each type of backend (e.g. client backend, checkpointer). Some BackendTypes do not accumulate IO operations statistics and will not be included in the view. Some IOContexts are not used by some BackendTypes and will not be in the view. For example, checkpointer does not use a BufferAccessStrategy (currently), so there will be no row for the relevant BufferAccessStrategy IOContext for checkpointer. Some IOOps are invalid in combination with certain IOContexts. Those cells will be NULL in the view to distinguish between 0 observed IOOps of that type and an invalid combination. For example, local buffers are not fsync'd so cells for all BackendTypes for IOCONTEXT_LOCAL and IOOP_FSYNC will be NULL. Some BackendTypes never perform certain IOOps. Those cells will also be NULL in the view. For example, bgwriter should not perform reads. View stats are populated with statistics incremented when a backend performs an IO Operation and maintained by the cumulative statistics subsystem. Each row of the view shows stats for a particular BackendType and IOContext combination (e.g. shared buffer accesses by checkpointer) and each column in the view is the total number of IO Operations done (e.g. writes). So a cell in the view would be, for example, the number of shared buffers written by checkpointer since the last stats reset. In anticipation of tracking WAL IO and non-block-oriented IO (such as temporary file IO), the "unit" column specifies the unit of the "acquired", "read", "written", and "extended" columns for a given row. Note that some of the cells in the view are redundant with fields in pg_stat_bgwriter (e.g. buffers_backend), however these have been kept in pg_stat_bgwriter for backwards compatibility. Deriving the redundant pg_stat_bgwriter stats from the IO operations stats structures was also problematic due to the separate reset targets for 'bgwriter' and 'io'. Suggested by Andres Freund Author: Melanie Plageman <melanieplage...@gmail.com> Reviewed-by: Andres Freund <and...@anarazel.de> Reviewed-by: Justin Pryzby <pry...@telsasoft.com> Reviewed-by: Kyotaro Horiguchi <horikyota....@gmail.com> Reviewed-by: Maciek Sakrejda <m.sakre...@gmail.com> Reviewed-by: Lukas Fittl <lu...@fittl.com> Discussion: https://www.postgresql.org/message-id/flat/20200124195226.lth52iydq2n2uilq%40alap3.anarazel.de --- doc/src/sgml/monitoring.sgml | 200 ++++++++++++++++++++- src/backend/catalog/system_views.sql | 14 ++ src/backend/utils/adt/pgstatfuncs.c | 123 +++++++++++++ src/include/catalog/pg_proc.dat | 9 + src/test/regress/expected/rules.out | 11 ++ src/test/regress/expected/stats.out | 256 +++++++++++++++++++++++++++ src/test/regress/sql/stats.sql | 134 ++++++++++++++ 7 files changed, 745 insertions(+), 2 deletions(-) diff --git a/doc/src/sgml/monitoring.sgml b/doc/src/sgml/monitoring.sgml index 14dfd650f8..9e17d1e1ec 100644 --- a/doc/src/sgml/monitoring.sgml +++ b/doc/src/sgml/monitoring.sgml @@ -448,6 +448,15 @@ postgres 27093 0.0 0.0 30096 2752 ? Ss 11:34 0:00 postgres: ser </entry> </row> + <row> + <entry><structname>pg_stat_io</structname><indexterm><primary>pg_stat_io</primary></indexterm></entry> + <entry>A row for each IO Context for each backend type showing + statistics about backend IO operations. See + <link linkend="monitoring-pg-stat-io-view"> + <structname>pg_stat_io</structname></link> for details. + </entry> + </row> + <row> <entry><structname>pg_stat_wal</structname><indexterm><primary>pg_stat_wal</primary></indexterm></entry> <entry>One row only, showing statistics about WAL activity. See @@ -3600,13 +3609,12 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i <structfield>stats_reset</structfield> <type>timestamp with time zone</type> </para> <para> - Time at which these statistics were last reset + Time at which these statistics were last reset. </para></entry> </row> </tbody> </tgroup> </table> - <para> Normally, WAL files are archived in order, oldest to newest, but that is not guaranteed, and does not hold under special circumstances like when @@ -3615,7 +3623,195 @@ SELECT pid, wait_event_type, wait_event FROM pg_stat_activity WHERE wait_event i <structfield>last_archived_wal</structfield> have also been successfully archived. </para> + </sect2> + + <sect2 id="monitoring-pg-stat-io-view"> + <title><structname>pg_stat_io</structname></title> + + <indexterm> + <primary>pg_stat_io</primary> + </indexterm> + + <para> + The <structname>pg_stat_io</structname> view has a row for each backend type + and IO context containing global data for the cluster on IO operations done + by that backend type in that IO context. Currently, only a subset of IO + operations are tracked here. WAL IO, IO on temporary files, and some forms + of IO outside of shared buffers (such as when building indexes or moving a + table from one tablespace to another) could be added in the future. + </para> + + <table id="pg-stat-io-view" xreflabel="pg_stat_io"> + <title><structname>pg_stat_io</structname> View</title> + <tgroup cols="1"> + <thead> + <row> + <entry role="catalog_table_entry"><para role="column_definition"> + Column Type + </para> + <para> + Description + </para></entry> + </row> + </thead> + <tbody> + <row> + <entry role="catalog_table_entry"><para role="column_definition"> + <structfield>backend_type</structfield> <type>text</type> + </para> + <para> + Type of backend (e.g. background worker, autovacuum worker). + </para></entry> + </row> + + <row> + <entry role="catalog_table_entry"><para role="column_definition"> + <structfield>io_context</structfield> <type>text</type> + </para> + <para> + IO Context used. This refers to the context or location of an IO + operation. + <literal>shared</literal> refers to shared buffers, the primary + buffer pool for relation data. + <literal>local</literal> refers to + process-local memory used for temporary tables. + <literal>vacuum</literal> refers to memory reserved for use during + vacuumming and analyzing. + <literal>bulkread</literal> + refers to memory reserved for use during bulk read operations. + <literal>bulkwrite</literal> + refers to memory reserved for use during bulk write operations. + The autovacuum daemon, explicit <command>VACUUM</command>, explicit + <command>ANALYZE</command>, many bulk reads, and many bulk writes use a + fixed amount of memory, acquiring the equivalent number of shared + buffers and reusing them circularly to avoid occupying an undue portion + of the main shared buffer pool. + </para></entry> + </row> + + <row> + <entry role="catalog_table_entry"><para role="column_definition"> + <structfield>acquired</structfield> <type>bigint</type> + </para> + <para> + Acquisitions of memory by this <varname>backend_type</varname> for + performing IO operations in this <varname>io_context</varname>. For + block-oriented IO, <varname>acquired</varname> is the number of buffers + acquired or reused as part of a buffer access strategy. + </para></entry> + </row> + + <row> + <entry role="catalog_table_entry"><para role="column_definition"> + <structfield>hit</structfield> <type>bigint</type> + </para> + <para> + Relevant only for block-based IO of data accessed in the course of + satisfying queries, <varname>hit</varname> is the number of number of + accesses of blocks already located in a + <productname>PostgreSQL</productname> buffer in this specified + <varname>io_context</varname> by this <varname>backend_type</varname>. + </para></entry> + </row> + + <row> + <entry role="catalog_table_entry"><para role="column_definition"> + <structfield>read</structfield> <type>bigint</type> + </para> + <para> + Reads by this <varname>backend_type</varname> into + memory or buffers in this <varname>io_context</varname>. + </para></entry> + </row> + + <row> + <entry role="catalog_table_entry"><para role="column_definition"> + <structfield>written</structfield> <type>bigint</type> + </para> + <para> + Writes of data in this <varname>io_context</varname> written out by this + <varname>backend_type</varname>. + Note that the values of <varname>written</varname> for + <varname>backend_type</varname> <literal>background writer</literal> and + <varname>backend_type</varname> <literal>checkpointer</literal> are + equivalent to the values of <varname>buffers_clean</varname> and + <varname>buffers_checkpoint</varname>, respectively, in <link + linkend="monitoring-pg-stat-bgwriter-view"> + <structname>pg_stat_bgwriter</structname></link>. + Also, the sum of <varname>written</varname> and + <varname>extended</varname> in this view for + <varname>backend_type</varname>s <literal>client backend</literal>, + <literal>autovacuum worker</literal>, <literal>background + worker</literal>, and <literal>walsender</literal> in + <varname>io_context</varname>s <literal>shared</literal>, + <literal>bulkread</literal>, <literal>bulkwrite</literal>, and + <literal>vacuum</literal> is equivalent to + <varname>buffers_backend</varname> in + <structname>pg_stat_bgwriter</structname>. + </para></entry> + </row> + + <row> + <entry role="catalog_table_entry"><para role="column_definition"> + <structfield>extended</structfield> <type>bigint</type> + </para> + <para> + Extends of relations done by this <varname>backend_type</varname> in + order to write data in this <varname>io_context</varname>. + </para></entry> + </row> + <row> + <entry role="catalog_table_entry"><para role="column_definition"> + <structfield>unit</structfield> <type>text</type> + </para> + <para> + The unit in which the acquired, read, written, and extended columns can + be interpreted. Currently <varname>block_size</varname> is the only + possible value. Reads, writes, and extends of relation data are done in + <varname>block_size</varname> units. Future values could include + <varname>wal_block_size</varname>, once WAL IO is tracked in this view, + and <quote>bytes</quote>, once non-block-oriented IO such as temp files + is tracked here. + </para></entry> + </row> + + <row> + <entry role="catalog_table_entry"><para role="column_definition"> + <structfield>fsynced</structfield> <type>bigint</type> + </para> + <para> + Number of fsyncs performed by this <varname>backend_type</varname> for + the purpose of persisting data present in this + <varname>io_context</varname>. <literal>fsyncs</literal> are done at + segment boundaries so <varname>unit</varname> does not apply to + <varname>fsynced</varname> column. <literal>fsyncs</literal> done by + backends in order to persist data written in + <varname>io_context</varname> <literal>vacuum</literal>, + <varname>io_context</varname> <literal>bulkread</literal>, or + <varname>io_context</varname> <literal>bulkwrite</literal> are counted + as an <varname>io_context</varname> <literal>shared</literal> + <literal>fsync</literal>. + Note that the sum of <varname>fsynced</varname> for all + <varname>io_context</varname> <literal>shared</literal> for all + <varname>backend_type</varname>s except <literal>checkpointer</literal> + is equivalent to <varname>buffers_backend_fsync</varname> in <link + linkend="monitoring-pg-stat-bgwriter-view"> + <structname>pg_stat_bgwriter</structname></link>. + </para></entry> + </row> + + <row> + <entry role="catalog_table_entry"><para role="column_definition"> + <structfield>stats_reset</structfield> <type>timestamp with time zone</type> + </para> + <para> + Time at which these statistics were last reset. + </para></entry> + </row> + </tbody> + </tgroup> + </table> </sect2> <sect2 id="monitoring-pg-stat-bgwriter-view"> diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql index 55f7ec79e0..6d6c5c6260 100644 --- a/src/backend/catalog/system_views.sql +++ b/src/backend/catalog/system_views.sql @@ -1114,6 +1114,20 @@ CREATE VIEW pg_stat_bgwriter AS pg_stat_get_buf_alloc() AS buffers_alloc, pg_stat_get_bgwriter_stat_reset_time() AS stats_reset; +CREATE VIEW pg_stat_io AS +SELECT + b.backend_type, + b.io_context, + b.acquired, + b.hit, + b.read, + b.written, + b.extended, + b.unit, + b.fsynced, + b.stats_reset +FROM pg_stat_get_io() b; + CREATE VIEW pg_stat_wal AS SELECT w.wal_records, diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c index edd73e5c25..6044cc35d1 100644 --- a/src/backend/utils/adt/pgstatfuncs.c +++ b/src/backend/utils/adt/pgstatfuncs.c @@ -1712,6 +1712,129 @@ pg_stat_get_buf_alloc(PG_FUNCTION_ARGS) PG_RETURN_INT64(pgstat_fetch_stat_bgwriter()->buf_alloc); } +/* +* When adding a new column to the pg_stat_io view, add a new enum value +* here above IO_NUM_COLUMNS. +*/ +typedef enum io_stat_col +{ + IO_COL_BACKEND_TYPE, + IO_COL_IO_CONTEXT, + IO_COL_ALLOCS, + IO_COL_HITS, + IO_COL_READS, + IO_COL_WRITES, + IO_COL_EXTENDS, + IO_COL_UNIT, + IO_COL_FSYNCS, + IO_COL_RESET_TIME, + IO_NUM_COLUMNS, +} io_stat_col; + +/* + * When adding a new IOOp, add a new io_stat_col and add a case to this + * function returning the corresponding io_stat_col. + */ +static io_stat_col +pgstat_io_op_get_index(IOOp io_op) +{ + switch (io_op) + { + case IOOP_ACQUIRE: + return IO_COL_ALLOCS; + case IOOP_HIT: + return IO_COL_HITS; + case IOOP_READ: + return IO_COL_READS; + case IOOP_WRITE: + return IO_COL_WRITES; + case IOOP_EXTEND: + return IO_COL_EXTENDS; + case IOOP_FSYNC: + return IO_COL_FSYNCS; + } + + elog(ERROR, "unrecognized IOOp value: %d", io_op); +} + +Datum +pg_stat_get_io(PG_FUNCTION_ARGS) +{ + PgStat_BackendIOContextOps *backends_io_stats; + ReturnSetInfo *rsinfo; + Datum reset_time; + + SetSingleFuncCall(fcinfo, 0); + rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; + + backends_io_stats = pgstat_fetch_backend_io_context_ops(); + + reset_time = TimestampTzGetDatum(backends_io_stats->stat_reset_timestamp); + + for (int bktype = 0; bktype < BACKEND_NUM_TYPES; bktype++) + { + Datum bktype_desc = CStringGetTextDatum(GetBackendTypeDesc(bktype)); + bool expect_backend_stats = true; + PgStat_IOContextOps *io_context_ops = &backends_io_stats->stats[bktype]; + + /* + * For those BackendTypes without IO Operation stats, skip + * representing them in the view altogether. + */ + expect_backend_stats = pgstat_io_op_stats_collected(bktype); + + for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++) + { + PgStat_IOOpCounters *counters = &io_context_ops->data[io_context]; + const char *io_context_str = pgstat_io_context_desc(io_context); + + Datum values[IO_NUM_COLUMNS] = {0}; + bool nulls[IO_NUM_COLUMNS] = {0}; + + /* + * Some combinations of IOContext and BackendType are not valid + * for any type of IOOp. In such cases, omit the entire row from + * the view. + */ + if (!expect_backend_stats || + !pgstat_bktype_io_context_valid(bktype, io_context)) + { + pgstat_io_context_ops_assert_zero(counters); + continue; + } + + values[IO_COL_BACKEND_TYPE] = bktype_desc; + values[IO_COL_IO_CONTEXT] = CStringGetTextDatum(io_context_str); + values[IO_COL_ALLOCS] = Int64GetDatum(counters->acquires); + values[IO_COL_HITS] = Int64GetDatum(counters->hits); + values[IO_COL_READS] = Int64GetDatum(counters->reads); + values[IO_COL_WRITES] = Int64GetDatum(counters->writes); + values[IO_COL_EXTENDS] = Int64GetDatum(counters->extends); + values[IO_COL_FSYNCS] = Int64GetDatum(counters->fsyncs); + values[IO_COL_UNIT] = CStringGetTextDatum("block_size"); + values[IO_COL_RESET_TIME] = TimestampTzGetDatum(reset_time); + + /* + * Some combinations of BackendType and IOOp and of IOContext and + * IOOp are not valid. Set these cells in the view NULL and assert + * that these stats are zero as expected. + */ + for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++) + { + if (!(pgstat_io_op_valid(bktype, io_context, io_op))) + { + pgstat_io_op_assert_zero(counters, io_op); + nulls[pgstat_io_op_get_index(io_op)] = true; + } + } + + tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls); + } + } + + return (Datum) 0; +} + /* * Returns statistics of WAL activity */ diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat index 68bb032d3e..f7341c51ca 100644 --- a/src/include/catalog/pg_proc.dat +++ b/src/include/catalog/pg_proc.dat @@ -5649,6 +5649,15 @@ proname => 'pg_stat_get_buf_alloc', provolatile => 's', proparallel => 'r', prorettype => 'int8', proargtypes => '', prosrc => 'pg_stat_get_buf_alloc' }, +{ oid => '8459', descr => 'statistics: per backend type IO statistics', + proname => 'pg_stat_get_io', provolatile => 'v', + prorows => '14', proretset => 't', + proparallel => 'r', prorettype => 'record', proargtypes => '', + proallargtypes => '{text,text,int8,int8,int8,int8,int8,text,int8,timestamptz}', + proargmodes => '{o,o,o,o,o,o,o,o,o,o}', + proargnames => '{backend_type,io_context,acquired,hit,read,written,extended,unit,fsynced,stats_reset}', + prosrc => 'pg_stat_get_io' }, + { oid => '1136', descr => 'statistics: information about WAL activity', proname => 'pg_stat_get_wal', proisstrict => 'f', provolatile => 's', proparallel => 'r', prorettype => 'record', proargtypes => '', diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out index 9dd137415e..8c00214958 100644 --- a/src/test/regress/expected/rules.out +++ b/src/test/regress/expected/rules.out @@ -1868,6 +1868,17 @@ pg_stat_gssapi| SELECT s.pid, s.gss_enc AS encrypted FROM pg_stat_get_activity(NULL::integer) s(datid, pid, usesysid, application_name, state, query, wait_event_type, wait_event, xact_start, query_start, backend_start, state_change, client_addr, client_hostname, client_port, backend_xid, backend_xmin, backend_type, ssl, sslversion, sslcipher, sslbits, ssl_client_dn, ssl_client_serial, ssl_issuer_dn, gss_auth, gss_princ, gss_enc, leader_pid, query_id) WHERE (s.client_port IS NOT NULL); +pg_stat_io| SELECT b.backend_type, + b.io_context, + b.acquired, + b.hit, + b.read, + b.written, + b.extended, + b.unit, + b.fsynced, + b.stats_reset + FROM pg_stat_get_io() b(backend_type, io_context, acquired, hit, read, written, extended, unit, fsynced, stats_reset); pg_stat_progress_analyze| SELECT s.pid, s.datid, d.datname, diff --git a/src/test/regress/expected/stats.out b/src/test/regress/expected/stats.out index f701da2069..779fb4d398 100644 --- a/src/test/regress/expected/stats.out +++ b/src/test/regress/expected/stats.out @@ -918,4 +918,260 @@ SELECT pg_stat_get_subscription_stats(NULL); (1 row) +-- Test that the following operations are tracked in pg_stat_io: +-- - acquisitions of shared buffers for IO operations +-- - reads of target blocks into shared buffers +-- - shared buffer cache hits when target blocks reside in shared buffers +-- - writes of shared buffers +-- - extends of relations using shared buffers +-- - fsyncs done to ensure the durability of data dirtying shared buffers +SELECT sum(acquired) AS io_sum_shared_acquisitions_before FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(hit) AS io_sum_shared_hits_before FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(read) AS io_sum_shared_reads_before FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(written) AS io_sum_shared_writes_before FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(extended) AS io_sum_shared_extends_before FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(fsynced) AS io_sum_shared_fsyncs_before FROM pg_stat_io WHERE io_context = 'shared' \gset +-- Create a regular table and insert some data to generate IOCONTEXT_SHARED +-- acquisitions and extends. +CREATE TABLE test_io_shared(a int); +INSERT INTO test_io_shared SELECT i FROM generate_series(1,100)i; +SELECT pg_stat_force_next_flush(); + pg_stat_force_next_flush +-------------------------- + +(1 row) + +-- After a checkpoint, there should be some additional IOCONTEXT_SHARED writes +-- and fsyncs. +-- The second checkpoint ensures that stats from the first checkpoint have been +-- reported and protects against any potential races amongst the table +-- creation, a possible timing-triggered checkpoint, and the explicit +-- checkpoint in the test. +CHECKPOINT; +CHECKPOINT; +SELECT sum(acquired) AS io_sum_shared_acquisitions_after FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(written) AS io_sum_shared_writes_after FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(extended) AS io_sum_shared_extends_after FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(fsynced) AS io_sum_shared_fsyncs_after FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT :io_sum_shared_acquisitions_after > :io_sum_shared_acquisitions_before; + ?column? +---------- + t +(1 row) + +SELECT :io_sum_shared_writes_after > :io_sum_shared_writes_before; + ?column? +---------- + t +(1 row) + +SELECT :io_sum_shared_extends_after > :io_sum_shared_extends_before; + ?column? +---------- + t +(1 row) + +SELECT current_setting('fsync') = 'off' OR :io_sum_shared_fsyncs_after > :io_sum_shared_fsyncs_before; + ?column? +---------- + t +(1 row) + +-- Change the tablespace so that the table is rewritten directly, then SELECT +-- from it to cause it to be read back into shared buffers. +SET allow_in_place_tablespaces = true; +CREATE TABLESPACE test_io_shared_stats_tblspc LOCATION ''; +ALTER TABLE test_io_shared SET TABLESPACE test_io_shared_stats_tblspc; +SELECT COUNT(*) FROM test_io_shared; + count +------- + 100 +(1 row) + +SELECT pg_stat_force_next_flush(); + pg_stat_force_next_flush +-------------------------- + +(1 row) + +SELECT sum(read) AS io_sum_shared_reads_after FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT :io_sum_shared_reads_after > :io_sum_shared_reads_before; + ?column? +---------- + t +(1 row) + +-- Select from the table again once it is in shared buffers. There should be +-- some hits recorded in pg_stat_io. +SELECT sum(hit) AS io_sum_shared_hits_after FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT :io_sum_shared_hits_after > :io_sum_shared_hits_before; + ?column? +---------- + t +(1 row) + +DROP TABLE test_io_shared; +DROP TABLESPACE test_io_shared_stats_tblspc; +-- Test that acquisitions of local buffers, reads of temporary table blocks +-- into local buffers, temporary table block cache hits in local buffers, +-- writes of local buffers, and extends of temporary tables are tracked in +-- pg_stat_io. +-- Set temp_buffers to a low value so that we can trigger writes with fewer +-- inserted tuples. Do so in a new session in case temporary tables have been +-- accessed by previous tests in this session. +\c +SET temp_buffers TO '1MB'; +CREATE TEMPORARY TABLE test_io_local(a int, b TEXT); +SELECT sum(acquired) AS io_sum_local_acquisitions_before FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(hit) AS io_sum_local_hits_before FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(read) AS io_sum_local_reads_before FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(written) AS io_sum_local_writes_before FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(extended) AS io_sum_local_extends_before FROM pg_stat_io WHERE io_context = 'local' \gset +-- Insert enough values that we need to reuse and write out dirty local +-- buffers. +INSERT INTO test_io_local SELECT generate_series(1, 8000) as id, repeat('a', 100); +-- Read in evicted buffers. +SELECT COUNT(*) FROM test_io_local; + count +------- + 8000 +(1 row) + +-- Query tuples in local buffers to ensure new local buffer cache hits. +SELECT COUNT(*) FROM test_io_local; + count +------- + 8000 +(1 row) + +SELECT pg_stat_force_next_flush(); + pg_stat_force_next_flush +-------------------------- + +(1 row) + +SELECT sum(acquired) AS io_sum_local_acquisitions_after FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(hit) AS io_sum_local_hits_after FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(read) AS io_sum_local_reads_after FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(written) AS io_sum_local_writes_after FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(extended) AS io_sum_local_extends_after FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT :io_sum_local_acquisitions_after > :io_sum_local_acquisitions_before; + ?column? +---------- + t +(1 row) + +SELECT :io_sum_local_reads_after > :io_sum_local_reads_before; + ?column? +---------- + t +(1 row) + +SELECT :io_sum_local_hits_after > :io_sum_local_hits_before; + ?column? +---------- + t +(1 row) + +SELECT :io_sum_local_writes_after > :io_sum_local_writes_before; + ?column? +---------- + t +(1 row) + +SELECT :io_sum_local_extends_after > :io_sum_local_extends_before; + ?column? +---------- + t +(1 row) + +RESET temp_buffers; +-- Test that reuse of strategy buffers and reads of blocks into these reused +-- buffers while VACUUMing are tracked in pg_stat_io. +-- Set wal_skip_threshold smaller than the expected size of +-- test_io_vac_strategy so that, even if wal_level is minimal, VACUUM FULL will +-- fsync the newly rewritten test_io_vac_strategy instead of writing it to WAL. +-- Writing it to WAL will result in the newly written relation pages being in +-- shared buffers -- preventing us from testing BAS_VACUUM BufferAccessStrategy +-- acquisitions and reads. +SET wal_skip_threshold = '1 kB'; +SELECT sum(acquired) AS io_sum_vac_strategy_acquisitions_before FROM pg_stat_io WHERE io_context = 'vacuum' \gset +SELECT sum(read) AS io_sum_vac_strategy_reads_before FROM pg_stat_io WHERE io_context = 'vacuum' \gset +CREATE TABLE test_io_vac_strategy(a int, b int) WITH (autovacuum_enabled = 'false'); +INSERT INTO test_io_vac_strategy SELECT i, i from generate_series(1, 8000)i; +-- Ensure that the next VACUUM will need to perform IO by rewriting the table +-- first with VACUUM (FULL). +VACUUM (FULL) test_io_vac_strategy; +VACUUM (PARALLEL 0) test_io_vac_strategy; +SELECT pg_stat_force_next_flush(); + pg_stat_force_next_flush +-------------------------- + +(1 row) + +SELECT sum(acquired) AS io_sum_vac_strategy_acquisitions_after FROM pg_stat_io WHERE io_context = 'vacuum' \gset +SELECT sum(read) AS io_sum_vac_strategy_reads_after FROM pg_stat_io WHERE io_context = 'vacuum' \gset +SELECT :io_sum_vac_strategy_acquisitions_after > :io_sum_vac_strategy_acquisitions_before; + ?column? +---------- + t +(1 row) + +SELECT :io_sum_vac_strategy_reads_after > :io_sum_vac_strategy_reads_before; + ?column? +---------- + t +(1 row) + +RESET wal_skip_threshold; +-- Test that extends done by a CTAS, which uses a BAS_BULKWRITE +-- BufferAccessStrategy, are tracked in pg_stat_io. +SELECT sum(extended) AS io_sum_bulkwrite_strategy_extends_before FROM pg_stat_io WHERE io_context = 'bulkwrite' \gset +CREATE TABLE test_io_bulkwrite_strategy AS SELECT i FROM generate_series(1,100)i; +SELECT pg_stat_force_next_flush(); + pg_stat_force_next_flush +-------------------------- + +(1 row) + +SELECT sum(extended) AS io_sum_bulkwrite_strategy_extends_after FROM pg_stat_io WHERE io_context = 'bulkwrite' \gset +SELECT :io_sum_bulkwrite_strategy_extends_after > :io_sum_bulkwrite_strategy_extends_before; + ?column? +---------- + t +(1 row) + +-- Test that reads of blocks into reused strategy buffers during database +-- creation, which uses a BAS_BULKREAD BufferAccessStrategy, are tracked in +-- pg_stat_io. +SELECT sum(read) AS io_sum_bulkread_strategy_reads_before FROM pg_stat_io WHERE io_context = 'bulkread' \gset +CREATE DATABASE test_io_bulkread_strategy_db; +SELECT pg_stat_force_next_flush(); + pg_stat_force_next_flush +-------------------------- + +(1 row) + +SELECT sum(read) AS io_sum_bulkread_strategy_reads_after FROM pg_stat_io WHERE io_context = 'bulkread' \gset +SELECT :io_sum_bulkread_strategy_reads_after > :io_sum_bulkread_strategy_reads_before; + ?column? +---------- + t +(1 row) + +-- Test IO stats reset +SELECT sum(acquired) + sum(extended) + sum(fsynced) + sum(read) + sum(written) AS io_stats_pre_reset FROM pg_stat_io \gset +SELECT pg_stat_reset_shared('io'); + pg_stat_reset_shared +---------------------- + +(1 row) + +SELECT sum(acquired) + sum(extended) + sum(fsynced) + sum(read) + sum(written) AS io_stats_post_reset FROM pg_stat_io \gset +SELECT :io_stats_post_reset < :io_stats_pre_reset; + ?column? +---------- + t +(1 row) + -- End of Stats Test diff --git a/src/test/regress/sql/stats.sql b/src/test/regress/sql/stats.sql index eb081f65a4..b4f4359035 100644 --- a/src/test/regress/sql/stats.sql +++ b/src/test/regress/sql/stats.sql @@ -449,4 +449,138 @@ SELECT pg_stat_get_replication_slot(NULL); SELECT pg_stat_get_subscription_stats(NULL); +-- Test that the following operations are tracked in pg_stat_io: +-- - acquisitions of shared buffers for IO operations +-- - reads of target blocks into shared buffers +-- - shared buffer cache hits when target blocks reside in shared buffers +-- - writes of shared buffers +-- - extends of relations using shared buffers +-- - fsyncs done to ensure the durability of data dirtying shared buffers +SELECT sum(acquired) AS io_sum_shared_acquisitions_before FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(hit) AS io_sum_shared_hits_before FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(read) AS io_sum_shared_reads_before FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(written) AS io_sum_shared_writes_before FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(extended) AS io_sum_shared_extends_before FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(fsynced) AS io_sum_shared_fsyncs_before FROM pg_stat_io WHERE io_context = 'shared' \gset +-- Create a regular table and insert some data to generate IOCONTEXT_SHARED +-- acquisitions and extends. +CREATE TABLE test_io_shared(a int); +INSERT INTO test_io_shared SELECT i FROM generate_series(1,100)i; +SELECT pg_stat_force_next_flush(); +-- After a checkpoint, there should be some additional IOCONTEXT_SHARED writes +-- and fsyncs. +-- The second checkpoint ensures that stats from the first checkpoint have been +-- reported and protects against any potential races amongst the table +-- creation, a possible timing-triggered checkpoint, and the explicit +-- checkpoint in the test. +CHECKPOINT; +CHECKPOINT; +SELECT sum(acquired) AS io_sum_shared_acquisitions_after FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(written) AS io_sum_shared_writes_after FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(extended) AS io_sum_shared_extends_after FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT sum(fsynced) AS io_sum_shared_fsyncs_after FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT :io_sum_shared_acquisitions_after > :io_sum_shared_acquisitions_before; +SELECT :io_sum_shared_writes_after > :io_sum_shared_writes_before; +SELECT :io_sum_shared_extends_after > :io_sum_shared_extends_before; +SELECT current_setting('fsync') = 'off' OR :io_sum_shared_fsyncs_after > :io_sum_shared_fsyncs_before; +-- Change the tablespace so that the table is rewritten directly, then SELECT +-- from it to cause it to be read back into shared buffers. +SET allow_in_place_tablespaces = true; +CREATE TABLESPACE test_io_shared_stats_tblspc LOCATION ''; +ALTER TABLE test_io_shared SET TABLESPACE test_io_shared_stats_tblspc; +SELECT COUNT(*) FROM test_io_shared; +SELECT pg_stat_force_next_flush(); +SELECT sum(read) AS io_sum_shared_reads_after FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT :io_sum_shared_reads_after > :io_sum_shared_reads_before; +-- Select from the table again once it is in shared buffers. There should be +-- some hits recorded in pg_stat_io. +SELECT sum(hit) AS io_sum_shared_hits_after FROM pg_stat_io WHERE io_context = 'shared' \gset +SELECT :io_sum_shared_hits_after > :io_sum_shared_hits_before; +DROP TABLE test_io_shared; +DROP TABLESPACE test_io_shared_stats_tblspc; + +-- Test that acquisitions of local buffers, reads of temporary table blocks +-- into local buffers, temporary table block cache hits in local buffers, +-- writes of local buffers, and extends of temporary tables are tracked in +-- pg_stat_io. + +-- Set temp_buffers to a low value so that we can trigger writes with fewer +-- inserted tuples. Do so in a new session in case temporary tables have been +-- accessed by previous tests in this session. +\c +SET temp_buffers TO '1MB'; +CREATE TEMPORARY TABLE test_io_local(a int, b TEXT); +SELECT sum(acquired) AS io_sum_local_acquisitions_before FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(hit) AS io_sum_local_hits_before FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(read) AS io_sum_local_reads_before FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(written) AS io_sum_local_writes_before FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(extended) AS io_sum_local_extends_before FROM pg_stat_io WHERE io_context = 'local' \gset +-- Insert enough values that we need to reuse and write out dirty local +-- buffers. +INSERT INTO test_io_local SELECT generate_series(1, 8000) as id, repeat('a', 100); +-- Read in evicted buffers. +SELECT COUNT(*) FROM test_io_local; +-- Query tuples in local buffers to ensure new local buffer cache hits. +SELECT COUNT(*) FROM test_io_local; +SELECT pg_stat_force_next_flush(); +SELECT sum(acquired) AS io_sum_local_acquisitions_after FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(hit) AS io_sum_local_hits_after FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(read) AS io_sum_local_reads_after FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(written) AS io_sum_local_writes_after FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT sum(extended) AS io_sum_local_extends_after FROM pg_stat_io WHERE io_context = 'local' \gset +SELECT :io_sum_local_acquisitions_after > :io_sum_local_acquisitions_before; +SELECT :io_sum_local_reads_after > :io_sum_local_reads_before; +SELECT :io_sum_local_hits_after > :io_sum_local_hits_before; +SELECT :io_sum_local_writes_after > :io_sum_local_writes_before; +SELECT :io_sum_local_extends_after > :io_sum_local_extends_before; +RESET temp_buffers; + +-- Test that reuse of strategy buffers and reads of blocks into these reused +-- buffers while VACUUMing are tracked in pg_stat_io. + +-- Set wal_skip_threshold smaller than the expected size of +-- test_io_vac_strategy so that, even if wal_level is minimal, VACUUM FULL will +-- fsync the newly rewritten test_io_vac_strategy instead of writing it to WAL. +-- Writing it to WAL will result in the newly written relation pages being in +-- shared buffers -- preventing us from testing BAS_VACUUM BufferAccessStrategy +-- acquisitions and reads. +SET wal_skip_threshold = '1 kB'; +SELECT sum(acquired) AS io_sum_vac_strategy_acquisitions_before FROM pg_stat_io WHERE io_context = 'vacuum' \gset +SELECT sum(read) AS io_sum_vac_strategy_reads_before FROM pg_stat_io WHERE io_context = 'vacuum' \gset +CREATE TABLE test_io_vac_strategy(a int, b int) WITH (autovacuum_enabled = 'false'); +INSERT INTO test_io_vac_strategy SELECT i, i from generate_series(1, 8000)i; +-- Ensure that the next VACUUM will need to perform IO by rewriting the table +-- first with VACUUM (FULL). +VACUUM (FULL) test_io_vac_strategy; +VACUUM (PARALLEL 0) test_io_vac_strategy; +SELECT pg_stat_force_next_flush(); +SELECT sum(acquired) AS io_sum_vac_strategy_acquisitions_after FROM pg_stat_io WHERE io_context = 'vacuum' \gset +SELECT sum(read) AS io_sum_vac_strategy_reads_after FROM pg_stat_io WHERE io_context = 'vacuum' \gset +SELECT :io_sum_vac_strategy_acquisitions_after > :io_sum_vac_strategy_acquisitions_before; +SELECT :io_sum_vac_strategy_reads_after > :io_sum_vac_strategy_reads_before; +RESET wal_skip_threshold; + +-- Test that extends done by a CTAS, which uses a BAS_BULKWRITE +-- BufferAccessStrategy, are tracked in pg_stat_io. +SELECT sum(extended) AS io_sum_bulkwrite_strategy_extends_before FROM pg_stat_io WHERE io_context = 'bulkwrite' \gset +CREATE TABLE test_io_bulkwrite_strategy AS SELECT i FROM generate_series(1,100)i; +SELECT pg_stat_force_next_flush(); +SELECT sum(extended) AS io_sum_bulkwrite_strategy_extends_after FROM pg_stat_io WHERE io_context = 'bulkwrite' \gset +SELECT :io_sum_bulkwrite_strategy_extends_after > :io_sum_bulkwrite_strategy_extends_before; + +-- Test that reads of blocks into reused strategy buffers during database +-- creation, which uses a BAS_BULKREAD BufferAccessStrategy, are tracked in +-- pg_stat_io. +SELECT sum(read) AS io_sum_bulkread_strategy_reads_before FROM pg_stat_io WHERE io_context = 'bulkread' \gset +CREATE DATABASE test_io_bulkread_strategy_db; +SELECT pg_stat_force_next_flush(); +SELECT sum(read) AS io_sum_bulkread_strategy_reads_after FROM pg_stat_io WHERE io_context = 'bulkread' \gset +SELECT :io_sum_bulkread_strategy_reads_after > :io_sum_bulkread_strategy_reads_before; + +-- Test IO stats reset +SELECT sum(acquired) + sum(extended) + sum(fsynced) + sum(read) + sum(written) AS io_stats_pre_reset FROM pg_stat_io \gset +SELECT pg_stat_reset_shared('io'); +SELECT sum(acquired) + sum(extended) + sum(fsynced) + sum(read) + sum(written) AS io_stats_post_reset FROM pg_stat_io \gset +SELECT :io_stats_post_reset < :io_stats_pre_reset; + -- End of Stats Test -- 2.34.1
From 6891009af39bd9fa66824a23fc34e37e5505d862 Mon Sep 17 00:00:00 2001 From: Melanie Plageman <melanieplage...@gmail.com> Date: Thu, 6 Oct 2022 12:23:25 -0400 Subject: [PATCH v31 1/3] Track IO operation statistics locally Introduce "IOOp", an IO operation done by a backend, and "IOContext", the IO source, target, or type done by a backend. For example, the checkpointer may write a shared buffer out. This would be counted as an IOOp "written" on an IOContext IOCONTEXT_SHARED by BackendType "checkpointer". Each IOOp (acquire, hit, read, write, extend, fsync) is counted per IOContext (bulkread, bulkwrite, local, shared, or vacuum) through a call to pgstat_count_io_op(). The primary concern of these statistics is IO operations on data blocks during the course of normal database operations. IO operations done by, for example, the archiver or syslogger are not counted in these statistics. WAL IO, temporary file IO, and IO done directly though smgr* functions (such as when building an index) are not yet counted but would be useful future additions. IOCONTEXT_LOCAL and IOCONTEXT_SHARED IOContexts concern operations on local and shared buffers. The IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, and IOCONTEXT_VACUUM IOContexts concern IO operations on buffers as part of a BufferAccessStrategy. IOOP_ACQUIRE IOOps are counted in IOCONTEXT_SHARED and IOCONTEXT_LOCAL IOContexts whenever a buffer is acquired through [Local]BufferAlloc(). IOOP_ACQUIRE IOOps are counted in the BufferAccessStrategy IOContexts whenever a buffer already in the strategy ring is reused. IOOP_WRITE IOOps are counted in the BufferAccessStrategy IOContexts whenever the reused dirty buffer is written out. Stats on IOOps in all IOContexts for a given backend are counted in a backend's local memory. A subsequent commit will expose functions for aggregating and viewing these stats. Author: Melanie Plageman <melanieplage...@gmail.com> Reviewed-by: Andres Freund <and...@anarazel.de> Reviewed-by: Justin Pryzby <pry...@telsasoft.com> Reviewed-by: Kyotaro Horiguchi <horikyota....@gmail.com> Reviewed-by: Maciek Sakrejda <m.sakre...@gmail.com> Reviewed-by: Lukas Fittl <lu...@fittl.com> Discussion: https://www.postgresql.org/message-id/flat/20200124195226.lth52iydq2n2uilq%40alap3.anarazel.de --- src/backend/postmaster/checkpointer.c | 13 ++ src/backend/storage/buffer/bufmgr.c | 59 +++++- src/backend/storage/buffer/freelist.c | 52 ++++- src/backend/storage/buffer/localbuf.c | 5 + src/backend/storage/sync/sync.c | 2 + src/backend/utils/activity/Makefile | 1 + src/backend/utils/activity/meson.build | 1 + src/backend/utils/activity/pgstat_io_ops.c | 234 +++++++++++++++++++++ src/include/pgstat.h | 61 ++++++ src/include/storage/buf_internals.h | 2 +- src/include/storage/bufmgr.h | 7 +- src/tools/pgindent/typedefs.list | 4 + 12 files changed, 428 insertions(+), 13 deletions(-) create mode 100644 src/backend/utils/activity/pgstat_io_ops.c diff --git a/src/backend/postmaster/checkpointer.c b/src/backend/postmaster/checkpointer.c index 5fc076fc14..4ea4e6a298 100644 --- a/src/backend/postmaster/checkpointer.c +++ b/src/backend/postmaster/checkpointer.c @@ -1116,6 +1116,19 @@ ForwardSyncRequest(const FileTag *ftag, SyncRequestType type) if (!AmBackgroundWriterProcess()) CheckpointerShmem->num_backend_fsync++; LWLockRelease(CheckpointerCommLock); + + /* + * We have no way of knowing if the current IOContext is + * IOCONTEXT_SHARED or IOCONTEXT_[BULKREAD, BULKWRITE, VACUUM] at this + * point, so count the fsync as being in the IOCONTEXT_SHARED + * IOContext. This is probably okay, because the number of backend + * fsyncs doesn't say anything about the efficacy of the + * BufferAccessStrategy. And counting both fsyncs done in + * IOCONTEXT_SHARED and IOCONTEXT_[BULKREAD, BULKWRITE, VACUUM] under + * IOCONTEXT_SHARED is likely clearer when investigating the number of + * backend fsyncs. + */ + pgstat_count_io_op(IOOP_FSYNC, IOCONTEXT_SHARED); return false; } diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index 6b95381481..1c14e305c1 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -482,7 +482,7 @@ static BufferDesc *BufferAlloc(SMgrRelation smgr, BlockNumber blockNum, BufferAccessStrategy strategy, bool *foundPtr); -static void FlushBuffer(BufferDesc *buf, SMgrRelation reln); +static void FlushBuffer(BufferDesc *buf, SMgrRelation reln, IOContext io_context); static void FindAndDropRelationBuffers(RelFileLocator rlocator, ForkNumber forkNum, BlockNumber nForkBlock, @@ -823,6 +823,7 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, BufferDesc *bufHdr; Block bufBlock; bool found; + IOContext io_context; bool isExtend; bool isLocalBuf = SmgrIsTemp(smgr); @@ -833,6 +834,13 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, isExtend = (blockNum == P_NEW); + if (strategy) + io_context = IOContextForStrategy(strategy); + else if (isLocalBuf) + io_context = IOCONTEXT_LOCAL; + else + io_context = IOCONTEXT_SHARED; + TRACE_POSTGRESQL_BUFFER_READ_START(forkNum, blockNum, smgr->smgr_rlocator.locator.spcOid, smgr->smgr_rlocator.locator.dbOid, @@ -886,6 +894,8 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, /* if it was already in the buffer pool, we're done */ if (found) { + pgstat_count_io_op(IOOP_HIT, io_context); + if (!isExtend) { /* Just need to update stats before we exit */ @@ -986,10 +996,14 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, */ Assert(!(pg_atomic_read_u32(&bufHdr->state) & BM_VALID)); /* spinlock not needed */ - bufBlock = isLocalBuf ? LocalBufHdrGetBlock(bufHdr) : BufHdrGetBlock(bufHdr); + if (isLocalBuf) + bufBlock = LocalBufHdrGetBlock(bufHdr); + else + bufBlock = BufHdrGetBlock(bufHdr); if (isExtend) { + pgstat_count_io_op(IOOP_EXTEND, io_context); /* new buffers are zero-filled */ MemSet((char *) bufBlock, 0, BLCKSZ); /* don't set checksum for all-zero page */ @@ -1020,6 +1034,8 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, smgrread(smgr, forkNum, blockNum, (char *) bufBlock); + pgstat_count_io_op(IOOP_READ, io_context); + if (track_io_timing) { INSTR_TIME_SET_CURRENT(io_time); @@ -1190,6 +1206,8 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, /* Loop here in case we have to try another victim buffer */ for (;;) { + bool from_ring; + /* * Ensure, while the spinlock's not yet held, that there's a free * refcount entry. @@ -1200,7 +1218,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, * Select a victim buffer. The buffer is returned with its header * spinlock still held! */ - buf = StrategyGetBuffer(strategy, &buf_state); + buf = StrategyGetBuffer(strategy, &buf_state, &from_ring); Assert(BUF_STATE_GET_REFCOUNT(buf_state) == 0); @@ -1237,6 +1255,8 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, if (LWLockConditionalAcquire(BufferDescriptorGetContentLock(buf), LW_SHARED)) { + IOContext io_context; + /* * If using a nondefault strategy, and writing the buffer * would require a WAL flush, let the strategy decide whether @@ -1263,13 +1283,28 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, } } + /* + * When a strategy is in use, if the target dirty buffer is an + * existing strategy buffer being reused, count this as a + * strategy write for the purposes of IO Operations statistics + * tracking. + * + * All dirty shared buffers upon first being added to the ring + * will be counted as shared buffer writes. + * + * When a strategy is not in use, the write can only be a + * "regular" write of a dirty shared buffer. + */ + + io_context = from_ring ? IOContextForStrategy(strategy) : IOCONTEXT_SHARED; + /* OK, do the I/O */ TRACE_POSTGRESQL_BUFFER_WRITE_DIRTY_START(forkNum, blockNum, smgr->smgr_rlocator.locator.spcOid, smgr->smgr_rlocator.locator.dbOid, smgr->smgr_rlocator.locator.relNumber); - FlushBuffer(buf, NULL); + FlushBuffer(buf, NULL, io_context); LWLockRelease(BufferDescriptorGetContentLock(buf)); ScheduleBufferTagForWriteback(&BackendWritebackContext, @@ -2570,7 +2605,7 @@ SyncOneBuffer(int buf_id, bool skip_recently_used, WritebackContext *wb_context) PinBuffer_Locked(bufHdr); LWLockAcquire(BufferDescriptorGetContentLock(bufHdr), LW_SHARED); - FlushBuffer(bufHdr, NULL); + FlushBuffer(bufHdr, NULL, IOCONTEXT_SHARED); LWLockRelease(BufferDescriptorGetContentLock(bufHdr)); @@ -2820,7 +2855,7 @@ BufferGetTag(Buffer buffer, RelFileLocator *rlocator, ForkNumber *forknum, * as the second parameter. If not, pass NULL. */ static void -FlushBuffer(BufferDesc *buf, SMgrRelation reln) +FlushBuffer(BufferDesc *buf, SMgrRelation reln, IOContext io_context) { XLogRecPtr recptr; ErrorContextCallback errcallback; @@ -2900,6 +2935,8 @@ FlushBuffer(BufferDesc *buf, SMgrRelation reln) */ bufToWrite = PageSetChecksumCopy((Page) bufBlock, buf->tag.blockNum); + pgstat_count_io_op(IOOP_WRITE, io_context); + if (track_io_timing) INSTR_TIME_SET_CURRENT(io_start); @@ -3551,6 +3588,8 @@ FlushRelationBuffers(Relation rel) localpage, false); + pgstat_count_io_op(IOOP_WRITE, IOCONTEXT_LOCAL); + buf_state &= ~(BM_DIRTY | BM_JUST_DIRTIED); pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state); @@ -3586,7 +3625,7 @@ FlushRelationBuffers(Relation rel) { PinBuffer_Locked(bufHdr); LWLockAcquire(BufferDescriptorGetContentLock(bufHdr), LW_SHARED); - FlushBuffer(bufHdr, RelationGetSmgr(rel)); + FlushBuffer(bufHdr, RelationGetSmgr(rel), IOCONTEXT_SHARED); LWLockRelease(BufferDescriptorGetContentLock(bufHdr)); UnpinBuffer(bufHdr); } @@ -3684,7 +3723,7 @@ FlushRelationsAllBuffers(SMgrRelation *smgrs, int nrels) { PinBuffer_Locked(bufHdr); LWLockAcquire(BufferDescriptorGetContentLock(bufHdr), LW_SHARED); - FlushBuffer(bufHdr, srelent->srel); + FlushBuffer(bufHdr, srelent->srel, IOCONTEXT_SHARED); LWLockRelease(BufferDescriptorGetContentLock(bufHdr)); UnpinBuffer(bufHdr); } @@ -3894,7 +3933,7 @@ FlushDatabaseBuffers(Oid dbid) { PinBuffer_Locked(bufHdr); LWLockAcquire(BufferDescriptorGetContentLock(bufHdr), LW_SHARED); - FlushBuffer(bufHdr, NULL); + FlushBuffer(bufHdr, NULL, IOCONTEXT_SHARED); LWLockRelease(BufferDescriptorGetContentLock(bufHdr)); UnpinBuffer(bufHdr); } @@ -3921,7 +3960,7 @@ FlushOneBuffer(Buffer buffer) Assert(LWLockHeldByMe(BufferDescriptorGetContentLock(bufHdr))); - FlushBuffer(bufHdr, NULL); + FlushBuffer(bufHdr, NULL, IOCONTEXT_SHARED); } /* diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 990e081aae..5fd65c17d1 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -15,6 +15,7 @@ */ #include "postgres.h" +#include "pgstat.h" #include "port/atomics.h" #include "storage/buf_internals.h" #include "storage/bufmgr.h" @@ -198,13 +199,15 @@ have_free_buffer(void) * return the buffer with the buffer header spinlock still held. */ BufferDesc * -StrategyGetBuffer(BufferAccessStrategy strategy, uint32 *buf_state) +StrategyGetBuffer(BufferAccessStrategy strategy, uint32 *buf_state, bool *from_ring) { BufferDesc *buf; int bgwprocno; int trycounter; uint32 local_buf_state; /* to avoid repeated (de-)referencing */ + *from_ring = false; + /* * If given a strategy object, see whether it can select a buffer. We * assume strategy objects don't need buffer_strategy_lock. @@ -213,7 +216,23 @@ StrategyGetBuffer(BufferAccessStrategy strategy, uint32 *buf_state) { buf = GetBufferFromRing(strategy, buf_state); if (buf != NULL) + { + /* + * When a BufferAccessStrategy is in use, reused buffers from the + * strategy ring will be counted as IOCONTEXT_BULKREAD, + * IOCONTEXT_BULKWRITE, or IOCONTEXT_VACUUM acquisitions for the + * purposes of IO Operation statistics tracking. + * + * However, even when a strategy is in use, if a new buffer must + * be acquired from shared buffers and added to the ring, this is + * counted instead as an IOCONTEXT_SHARED acquisition. So, only + * reused buffers are counted as having been acquired in a + * BufferAccessStrategy IOContext. + */ + *from_ring = true; + pgstat_count_io_op(IOOP_ACQUIRE, IOContextForStrategy(strategy)); return buf; + } } /* @@ -247,6 +266,7 @@ StrategyGetBuffer(BufferAccessStrategy strategy, uint32 *buf_state) * the rate of buffer consumption. Note that buffers recycled by a * strategy object are intentionally not counted here. */ + pgstat_count_io_op(IOOP_ACQUIRE, IOCONTEXT_SHARED); pg_atomic_fetch_add_u32(&StrategyControl->numBufferAllocs, 1); /* @@ -670,6 +690,36 @@ AddBufferToRing(BufferAccessStrategy strategy, BufferDesc *buf) strategy->buffers[strategy->current] = BufferDescriptorGetBuffer(buf); } +/* + * Utility function returning the IOContext of a given BufferAccessStrategy's + * strategy ring. + */ +IOContext +IOContextForStrategy(BufferAccessStrategy strategy) +{ + Assert(strategy); + + switch (strategy->btype) + { + case BAS_NORMAL: + + /* + * Currently, GetAccessStrategy() returns NULL for + * BufferAccessStrategyType BAS_NORMAL, so this case is unlikely + * to be hit. + */ + return IOCONTEXT_SHARED; + case BAS_BULKREAD: + return IOCONTEXT_BULKREAD; + case BAS_BULKWRITE: + return IOCONTEXT_BULKWRITE; + case BAS_VACUUM: + return IOCONTEXT_VACUUM; + } + + elog(ERROR, "unrecognized BufferAccessStrategyType: %d", strategy->btype); +} + /* * StrategyRejectBuffer -- consider rejecting a dirty buffer * diff --git a/src/backend/storage/buffer/localbuf.c b/src/backend/storage/buffer/localbuf.c index 30d67d1c40..c2548f2b0b 100644 --- a/src/backend/storage/buffer/localbuf.c +++ b/src/backend/storage/buffer/localbuf.c @@ -18,6 +18,7 @@ #include "access/parallel.h" #include "catalog/catalog.h" #include "executor/instrument.h" +#include "pgstat.h" #include "storage/buf_internals.h" #include "storage/bufmgr.h" #include "utils/guc_hooks.h" @@ -196,6 +197,8 @@ LocalBufferAlloc(SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum, LocalRefCount[b]++; ResourceOwnerRememberBuffer(CurrentResourceOwner, BufferDescriptorGetBuffer(bufHdr)); + + pgstat_count_io_op(IOOP_ACQUIRE, IOCONTEXT_LOCAL); break; } } @@ -226,6 +229,8 @@ LocalBufferAlloc(SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum, localpage, false); + pgstat_count_io_op(IOOP_WRITE, IOCONTEXT_LOCAL); + /* Mark not-dirty now in case we error out below */ buf_state &= ~BM_DIRTY; pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state); diff --git a/src/backend/storage/sync/sync.c b/src/backend/storage/sync/sync.c index 9d6a9e9109..5718b52fb5 100644 --- a/src/backend/storage/sync/sync.c +++ b/src/backend/storage/sync/sync.c @@ -432,6 +432,8 @@ ProcessSyncRequests(void) total_elapsed += elapsed; processed++; + pgstat_count_io_op(IOOP_FSYNC, IOCONTEXT_SHARED); + if (log_checkpoints) elog(DEBUG1, "checkpoint sync: number=%d file=%s time=%.3f ms", processed, diff --git a/src/backend/utils/activity/Makefile b/src/backend/utils/activity/Makefile index a2e8507fd6..0098785089 100644 --- a/src/backend/utils/activity/Makefile +++ b/src/backend/utils/activity/Makefile @@ -22,6 +22,7 @@ OBJS = \ pgstat_checkpointer.o \ pgstat_database.o \ pgstat_function.o \ + pgstat_io_ops.o \ pgstat_relation.o \ pgstat_replslot.o \ pgstat_shmem.o \ diff --git a/src/backend/utils/activity/meson.build b/src/backend/utils/activity/meson.build index 5b3b558a67..1038324c32 100644 --- a/src/backend/utils/activity/meson.build +++ b/src/backend/utils/activity/meson.build @@ -7,6 +7,7 @@ backend_sources += files( 'pgstat_checkpointer.c', 'pgstat_database.c', 'pgstat_function.c', + 'pgstat_io_ops.c', 'pgstat_relation.c', 'pgstat_replslot.c', 'pgstat_shmem.c', diff --git a/src/backend/utils/activity/pgstat_io_ops.c b/src/backend/utils/activity/pgstat_io_ops.c new file mode 100644 index 0000000000..cea46322a7 --- /dev/null +++ b/src/backend/utils/activity/pgstat_io_ops.c @@ -0,0 +1,234 @@ +/* ------------------------------------------------------------------------- + * + * pgstat_io_ops.c + * Implementation of IO operation statistics. + * + * This file contains the implementation of IO operation statistics. It is kept + * separate from pgstat.c to enforce the line between the statistics access / + * storage implementation and the details about individual types of + * statistics. + * + * Copyright (c) 2021-2022, PostgreSQL Global Development Group + * + * IDENTIFICATION + * src/backend/utils/activity/pgstat_io_ops.c + * ------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "utils/pgstat_internal.h" + +static PgStat_IOContextOps pending_IOOpStats; + +void +pgstat_count_io_op(IOOp io_op, IOContext io_context) +{ + PgStat_IOOpCounters *pending_counters; + + Assert(io_context < IOCONTEXT_NUM_TYPES); + Assert(io_op < IOOP_NUM_TYPES); + Assert(pgstat_expect_io_op(MyBackendType, io_context, io_op)); + + pending_counters = &pending_IOOpStats.data[io_context]; + + switch (io_op) + { + case IOOP_ACQUIRE: + pending_counters->acquires++; + break; + case IOOP_EXTEND: + pending_counters->extends++; + break; + case IOOP_FSYNC: + pending_counters->fsyncs++; + break; + case IOOP_HIT: + pending_counters->hits++; + break; + case IOOP_READ: + pending_counters->reads++; + break; + case IOOP_WRITE: + pending_counters->writes++; + break; + } + +} + +const char * +pgstat_io_context_desc(IOContext io_context) +{ + switch (io_context) + { + case IOCONTEXT_BULKREAD: + return "bulkread"; + case IOCONTEXT_BULKWRITE: + return "bulkwrite"; + case IOCONTEXT_LOCAL: + return "local"; + case IOCONTEXT_SHARED: + return "shared"; + case IOCONTEXT_VACUUM: + return "vacuum"; + } + + elog(ERROR, "unrecognized IOContext value: %d", io_context); +} + +const char * +pgstat_io_op_desc(IOOp io_op) +{ + switch (io_op) + { + case IOOP_ACQUIRE: + return "acquire"; + case IOOP_EXTEND: + return "extend"; + case IOOP_FSYNC: + return "fsync"; + case IOOP_HIT: + return "hit"; + case IOOP_READ: + return "read"; + case IOOP_WRITE: + return "write"; + } + + elog(ERROR, "unrecognized IOOp value: %d", io_op); +} + +/* +* IO Operation statistics are not collected for all BackendTypes. +* +* The following BackendTypes do not participate in the cumulative stats +* subsystem or do not do IO operations worth reporting statistics on: +* - Syslogger because it is not connected to shared memory +* - Archiver because most relevant archiving IO is delegated to a +* specialized command or module +* - WAL Receiver and WAL Writer IO is not tracked in pg_stat_io for now +* +* Function returns true if BackendType participates in the cumulative stats +* subsystem for IO Operations and false if it does not. +*/ +bool +pgstat_io_op_stats_collected(BackendType bktype) +{ + return bktype != B_INVALID && bktype != B_ARCHIVER && bktype != B_LOGGER && + bktype != B_WAL_RECEIVER && bktype != B_WAL_WRITER; +} + +/* + * Some BackendTypes will never do IO in certain IOContexts. Check that the + * given BackendType is expected to do IO in the given IOContext. + */ +bool +pgstat_bktype_io_context_valid(BackendType bktype, IOContext io_context) +{ + bool no_strategy; + bool no_local; + + /* + * In core Postgres, only regular backends and WAL Sender processes + * executing queries should use local buffers. Parallel workers will not + * use local buffers (see InitLocalBuffers()); however, extensions + * leveraging background workers have no such limitation, so track IO + * Operations in IOCONTEXT_LOCAL for BackendType B_BG_WORKER. + */ + no_local = bktype == B_AUTOVAC_LAUNCHER || bktype == B_BG_WRITER || bktype + == B_CHECKPOINTER || bktype == B_AUTOVAC_WORKER || bktype == + B_STANDALONE_BACKEND || bktype == B_STARTUP; + + if (io_context == IOCONTEXT_LOCAL && no_local) + return false; + + /* + * Some BackendTypes never use any BufferAccessStrategy. + */ + no_strategy = bktype == B_AUTOVAC_LAUNCHER || bktype == + B_BG_WRITER || bktype == B_CHECKPOINTER; + + if ((io_context == IOCONTEXT_BULKREAD || io_context == IOCONTEXT_BULKWRITE + || io_context == IOCONTEXT_VACUUM) && no_strategy) + return false; + + /* + * There is not an explicit reason why an autovacuum worker could not use + * a BAS_BULKREAD or BAS_BULKWRITE BufferAccessStrategy, however, they do + * not currently do so and leaving these combinations out leans out the + * view. If autovacuum workers use these strategies in the future, this + * restriction can be removed. + */ + if ((io_context == IOCONTEXT_BULKWRITE || io_context == IOCONTEXT_BULKREAD) + && bktype == B_AUTOVAC_WORKER) + return false; + + return true; +} + +/* + * Some BackendTypes will never do certain IOOps and some IOOps should not + * occur in certain IOContexts. Check that the given IOOp is valid for the + * given BackendType in the given IOContext. Note that there are currently no + * cases of an IOOp being invalid for a particular BackendType only within a + * certain IOContext. + */ +bool +pgstat_io_op_valid(BackendType bktype, IOContext io_context, IOOp io_op) +{ + bool strategy_io_context; + + /* + * Some BackendTypes should never track IO Operation statistics. + */ + Assert(pgstat_io_op_stats_collected(bktype)); + + /* + * Some BackendTypes will not do certain IOOps. + */ + if ((bktype == B_BG_WRITER || bktype == B_CHECKPOINTER) && + (io_op == IOOP_READ || io_op == IOOP_ACQUIRE || io_op == IOOP_HIT)) + return false; + + if ((bktype == B_AUTOVAC_LAUNCHER || bktype == B_BG_WRITER || bktype == + B_CHECKPOINTER) && io_op == IOOP_EXTEND) + return false; + + /* + * Some IOOps are not valid in certain IOContexts + */ + if (io_op == IOOP_EXTEND && io_context == IOCONTEXT_BULKREAD) + return false; + + /* + * Temporary tables using local buffers are not logged and thus do not + * require fsync'ing. + * + * IOOP_FSYNC IOOps done by a backend using a BufferAccessStrategy are + * counted in the IOCONTEXT_SHARED IOContext. See comment in + * ForwardSyncRequest() for more details. + */ + strategy_io_context = io_context == IOCONTEXT_BULKREAD || io_context == + IOCONTEXT_BULKWRITE || io_context == IOCONTEXT_VACUUM; + + if ((io_context == IOCONTEXT_LOCAL || strategy_io_context) && + io_op == IOOP_FSYNC) + return false; + + return true; +} + +bool +pgstat_expect_io_op(BackendType bktype, IOContext io_context, IOOp io_op) +{ + if (!pgstat_io_op_stats_collected(bktype)) + return false; + + if (!pgstat_bktype_io_context_valid(bktype, io_context)) + return false; + + if (!(pgstat_io_op_valid(bktype, io_context, io_op))) + return false; + + return true; +} diff --git a/src/include/pgstat.h b/src/include/pgstat.h index ad7334a0d2..472e0def97 100644 --- a/src/include/pgstat.h +++ b/src/include/pgstat.h @@ -14,6 +14,7 @@ #include "datatype/timestamp.h" #include "portability/instr_time.h" #include "postmaster/pgarch.h" /* for MAX_XFN_CHARS */ +#include "storage/buf.h" #include "utils/backend_progress.h" /* for backward compatibility */ #include "utils/backend_status.h" /* for backward compatibility */ #include "utils/relcache.h" @@ -276,6 +277,48 @@ typedef struct PgStat_CheckpointerStats PgStat_Counter buf_fsync_backend; } PgStat_CheckpointerStats; +/* + * Types related to counting IO Operations for various IO Contexts + */ + +typedef enum IOOp +{ + IOOP_ACQUIRE, + IOOP_EXTEND, + IOOP_FSYNC, + IOOP_HIT, + IOOP_READ, + IOOP_WRITE, +} IOOp; + +#define IOOP_NUM_TYPES (IOOP_WRITE + 1) + +typedef enum IOContext +{ + IOCONTEXT_BULKREAD, + IOCONTEXT_BULKWRITE, + IOCONTEXT_LOCAL, + IOCONTEXT_SHARED, + IOCONTEXT_VACUUM, +} IOContext; + +#define IOCONTEXT_NUM_TYPES (IOCONTEXT_VACUUM + 1) + +typedef struct PgStat_IOOpCounters +{ + PgStat_Counter acquires; + PgStat_Counter extends; + PgStat_Counter fsyncs; + PgStat_Counter hits; + PgStat_Counter reads; + PgStat_Counter writes; +} PgStat_IOOpCounters; + +typedef struct PgStat_IOContextOps +{ + PgStat_IOOpCounters data[IOCONTEXT_NUM_TYPES]; +} PgStat_IOContextOps; + typedef struct PgStat_StatDBEntry { PgStat_Counter n_xact_commit; @@ -453,6 +496,24 @@ extern void pgstat_report_checkpointer(void); extern PgStat_CheckpointerStats *pgstat_fetch_stat_checkpointer(void); +/* + * Functions in pgstat_io_ops.c + */ + +extern void pgstat_count_io_op(IOOp io_op, IOContext io_context); +extern const char *pgstat_io_context_desc(IOContext io_context); +extern const char *pgstat_io_op_desc(IOOp io_op); + +/* Validation functions in pgstat_io_ops.c */ +extern bool pgstat_io_op_stats_collected(BackendType bktype); +extern bool pgstat_bktype_io_context_valid(BackendType bktype, IOContext io_context); +extern bool pgstat_io_op_valid(BackendType bktype, IOContext io_context, IOOp io_op); +extern bool pgstat_expect_io_op(BackendType bktype, IOContext io_context, IOOp io_op); + +/* IO stats translation function in freelist.c */ +extern IOContext IOContextForStrategy(BufferAccessStrategy bas); + + /* * Functions in pgstat_database.c */ diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h index 406db6be78..50d7e586e9 100644 --- a/src/include/storage/buf_internals.h +++ b/src/include/storage/buf_internals.h @@ -392,7 +392,7 @@ extern void ScheduleBufferTagForWriteback(WritebackContext *context, BufferTag * /* freelist.c */ extern BufferDesc *StrategyGetBuffer(BufferAccessStrategy strategy, - uint32 *buf_state); + uint32 *buf_state, bool *from_ring); extern void StrategyFreeBuffer(BufferDesc *buf); extern bool StrategyRejectBuffer(BufferAccessStrategy strategy, BufferDesc *buf); diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h index 6f4dfa0960..d0eed71f63 100644 --- a/src/include/storage/bufmgr.h +++ b/src/include/storage/bufmgr.h @@ -23,7 +23,12 @@ typedef void *Block; -/* Possible arguments for GetAccessStrategy() */ +/* + * Possible arguments for GetAccessStrategy(). + * + * If adding a new BufferAccessStrategyType, also add a new IOContext so + * statistics on IO operations using this strategy are tracked. + */ typedef enum BufferAccessStrategyType { BAS_NORMAL, /* Normal random access */ diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 97c9bc1861..67218ec6f2 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -1106,7 +1106,9 @@ ID INFIX INT128 INTERFACE_INFO +IOContext IOFuncSelector +IOOp IPCompareMethod ITEM IV @@ -2026,6 +2028,8 @@ PgStat_FetchConsistency PgStat_FunctionCallUsage PgStat_FunctionCounts PgStat_HashKey +PgStat_IOContextOps +PgStat_IOOpCounters PgStat_Kind PgStat_KindInfo PgStat_LocalState -- 2.34.1
