From d1030146bc9b0c494a462de4761ceb1c45351cfb Mon Sep 17 00:00:00 2001 From: Jakub Wartak Date: Fri, 8 May 2026 09:19:49 +0200 Subject: [PATCH v15 3/3] Lower pg_stat_io_histogram shared memory use by using array with indirect offsets. We use pgstat_track_io_*() family of functions to derive the length of static array that is allocated in shared memory region during startup. As the number of valid combinations of backend types vs I/O object/context/operations is coming from semi-runtime pgstat_io_get_sum_tracked() function, it cannot be preprocessed, so we would need to come up with #define PGSTAT_IO_HIST_BUCKET_SLOTS somehow. In order to do that - and avoid that C limitations (lack of constexpr) - we could precalculate (in the build system) the size of static array and generate .h include that would be included by pgstat.h, however it appears that would be it hardly cross-portable and hardly cross-compilable. Instead of doing that, we dynamically allocate shared memory for IO historgrams during startup. --- src/backend/utils/activity/pgstat.c | 60 ++++++- src/backend/utils/activity/pgstat_io.c | 186 +++++++++++++++++++--- src/backend/utils/activity/pgstat_shmem.c | 15 ++ src/backend/utils/adt/pgstatfuncs.c | 27 +++- src/include/pgstat.h | 24 ++- 5 files changed, 284 insertions(+), 28 deletions(-) diff --git a/src/backend/utils/activity/pgstat.c b/src/backend/utils/activity/pgstat.c index 4585b3a8f92..b54844a4350 100644 --- a/src/backend/utils/activity/pgstat.c +++ b/src/backend/utils/activity/pgstat.c @@ -457,7 +457,13 @@ static const PgStat_KindInfo pgstat_kind_builtin_infos[PGSTAT_KIND_BUILTIN_SIZE] .snapshot_ctl_off = offsetof(PgStat_Snapshot, io), .shared_ctl_off = offsetof(PgStat_ShmemControl, io), .shared_data_off = offsetof(PgStatShared_IO, stats), - .shared_data_len = sizeof(((PgStatShared_IO *) 0)->stats), + + /* + * Do not write everything using this .shared_data_len, as the IO + * histogram backing store is handled by special-case (as it is + * dynamic) in pgstat_write_statsfile() / pgstat_read_statsfile(). + */ + .shared_data_len = offsetof(PgStat_IO, hist_time_buckets_slot_count), .init_backend_cb = pgstat_io_init_backend_cb, .flush_static_cb = pgstat_io_flush_cb, @@ -1742,6 +1748,21 @@ pgstat_write_statsfile(void) fputc(PGSTAT_FILE_ENTRY_FIXED, fpout); write_chunk_s(fpout, &kind); write_chunk(fpout, ptr, info->shared_data_len); + + /* + * PGSTAT_KIND_IO has a dynamically-sized histogram that lives outside + * the shared_data_len region. This assumes that PGSTAT_FILE_FORMAT_ID + * would be bumped each time that pgstat_track_io*() logic is altered. + */ + if (kind == PGSTAT_KIND_IO) + { + PgStat_IO *io = pgStatLocal.snapshot.io; + + write_chunk_s(fpout, &io->hist_time_buckets_slot_count); + write_chunk(fpout, io->hist_time_buckets_slots, + (size_t) io->hist_time_buckets_slot_count * + PGSTAT_IO_HIST_BUCKETS * sizeof(uint64)); + } } /* @@ -2006,6 +2027,43 @@ pgstat_read_statsfile(void) goto error; } + /* + * PGSTAT_KIND_IO has a dynamically-sized histogram array + * appended after the main chunk, preceded by its slot + * count. StatsShmemInit() already sized the backing + * store. The main chunk also contained the offset + * tables; those are re-derived from this binary's rules + * rather than trusted from the file. + */ + if (kind == PGSTAT_KIND_IO) + { + PgStat_IO *io = &shmem->io.stats; + int slot_count; + int histogram_slots = pgstat_io_init_hist_offsets(io); + + if (!read_chunk_s(fpin, &slot_count)) + { + elog(WARNING, "could not read pgstat_io histogram slot count"); + goto error; + } + + Assert(histogram_slots == io->hist_time_buckets_slot_count); + if (histogram_slots != slot_count) + { + elog(WARNING, "pgstat_io histogram slot count mismatch: file %d, expected %d", + slot_count, io->hist_time_buckets_slot_count); + goto error; + } + + if (!read_chunk(fpin, io->hist_time_buckets_slots, + (size_t) io->hist_time_buckets_slot_count * + PGSTAT_IO_HIST_BUCKETS * sizeof(uint64))) + { + elog(WARNING, "could not read pgstat_io histogram backing store"); + goto error; + } + } + break; } case PGSTAT_FILE_ENTRY_HASH: diff --git a/src/backend/utils/activity/pgstat_io.c b/src/backend/utils/activity/pgstat_io.c index e561ce55d58..d9a7f2d3de2 100644 --- a/src/backend/utils/activity/pgstat_io.c +++ b/src/backend/utils/activity/pgstat_io.c @@ -20,6 +20,7 @@ #include "executor/instrument.h" #include "port/pg_bitutils.h" #include "storage/bufmgr.h" +#include "storage/shmem.h" #include "utils/memutils.h" #include "utils/pgstat_internal.h" @@ -207,6 +208,8 @@ pgstat_count_io_op_time(IOObject io_object, IOContext io_context, IOOp io_op, { int offset; + Assert(track_io_timing || track_wal_io_timing); + /* * calculate the bucket_index based on latency in nanoseconds * (uint64) @@ -267,6 +270,7 @@ pgstat_io_flush_cb(bool nowait) { LWLock *bktype_lock; PgStat_BktypeIO *bktype_shstats; + PgStat_IO *bk_io; if (!have_iostats) return false; @@ -274,6 +278,7 @@ pgstat_io_flush_cb(bool nowait) bktype_lock = &pgStatLocal.shmem->io.locks[MyBackendType]; bktype_shstats = &pgStatLocal.shmem->io.stats.stats[MyBackendType]; + bk_io = &pgStatLocal.shmem->io.stats; if (!nowait) LWLockAcquire(bktype_lock, LW_EXCLUSIVE); @@ -306,16 +311,24 @@ pgstat_io_flush_cb(bool nowait) * offsets to save memory) into shared memory. */ if (PendingIOStats.pending_hist_time_buckets != NULL) - for (int b = 0; b < PGSTAT_IO_HIST_BUCKETS; b++) - { - int pending_off = PendingIOStats.pending_hist_time_buckets_offsets[io_object][io_context][io_op]; + { + int bktype_shstats_off = bktype_shstats->hist_time_buckets_offsets[io_object][io_context][io_op]; + int pending_off = PendingIOStats.pending_hist_time_buckets_offsets[io_object][io_context][io_op]; - if (pending_off != -1) - { - bktype_shstats->hist_time_buckets[io_object][io_context][io_op][b] += - PendingIOStats.pending_hist_time_buckets[pending_off][b]; - } - } + /* + * -1 means here that such mapping doesn't have a slot + * (based on pgstat_track_io_*()). + */ + if (bktype_shstats_off == -1 || pending_off == -1) + continue; + + Assert(bktype_shstats_off < bk_io->hist_time_buckets_slot_count); + Assert(pending_off < PendingIOStats.pending_hist_time_buckets_size); + + for (int b = 0; b < PGSTAT_IO_HIST_BUCKETS; b++) + bk_io->hist_time_buckets_slots[bktype_shstats_off][b] += + PendingIOStats.pending_hist_time_buckets[pending_off][b]; + } } } } @@ -424,7 +437,7 @@ pgstat_io_init_backend_cb(void) { if (pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op)) { - Assert(io_histograms_used <= PendingIOStats.pending_hist_time_buckets_size); + Assert(io_histograms_used < PendingIOStats.pending_hist_time_buckets_size); PendingIOStats.pending_hist_time_buckets_offsets[io_object][io_context][io_op] = io_histograms_used++; @@ -437,39 +450,115 @@ pgstat_io_init_backend_cb(void) } else PendingIOStats.pending_hist_time_buckets = NULL; +} +/* + * Establish the indirect mapping from + * PgStat_BktypeIO.hist_time_buckets_offsets[][][] to + * PgStat_IO.hist_time_buckets_slots[x], for all backend types. + * + * The mapping is a pure function of the pgstat_tracks_io_*() rules. It + * is recomputed rather than ever trusted from the PGSTAT file. Returns + * the number of slots used. + */ +int +pgstat_io_init_hist_offsets(PgStat_IO *io) +{ + int histogram_slots = 0; + + for (int i = 0; i < BACKEND_NUM_TYPES; i++) + { + for (int io_object = 0; io_object < IOOBJECT_NUM_TYPES; io_object++) + { + for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++) + { + for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++) + { + if (pgstat_tracks_io_op(i, io_object, io_context, io_op)) + io->stats[i].hist_time_buckets_offsets[io_object][io_context][io_op] = + histogram_slots++; + else + io->stats[i].hist_time_buckets_offsets[io_object][io_context][io_op] = + -1; + } + } + } + } + + return histogram_slots; } void pgstat_io_init_shmem_cb(void *stats) { PgStatShared_IO *stat_shmem = (PgStatShared_IO *) stats; + int histogram_slots PG_USED_FOR_ASSERTS_ONLY; for (int i = 0; i < BACKEND_NUM_TYPES; i++) LWLockInitialize(&stat_shmem->locks[i], LWTRANCHE_PGSTATS_DATA); - /* this might end up being lazily allocated in pgstat_io_snapshot_cb() */ - pgStatLocal.snapshot.io = NULL; + histogram_slots = pgstat_io_init_hist_offsets(&stat_shmem->stats); + + /* + * Sanity check: the offset table we just produced must use exactly the + * number of slots StatsShmemInit() reserved. Both come from the same + * pgstat_tracks_io_*() rules, so mismatch would indicate some bug. + */ + Assert(histogram_slots == stat_shmem->stats.hist_time_buckets_slot_count); } void pgstat_io_reset_all_cb(TimestampTz ts) { + PgStat_IO *io_stats = &pgStatLocal.shmem->io.stats; + int histogram_slots PG_USED_FOR_ASSERTS_ONLY; + + /* + * Never trust the offset tables currently in shared memory. This is also + * called via pgstat_reset_after_failure() when pgstat_read_statsfile() + * failed part-way through reading the PGSTAT_KIND_IO chunk, in which case + * hist_time_buckets_offsets may contain garbage from the file that would + * make the memset() below write outside of hist_time_buckets_slots. The + * mapping is a pure function of the pgstat_tracks_io_*() rules, so + * recomputing it here is cheap and yields the same values any concurrent + * reader already sees. + */ + histogram_slots = pgstat_io_init_hist_offsets(io_stats); + Assert(histogram_slots == io_stats->hist_time_buckets_slot_count); + for (int i = 0; i < BACKEND_NUM_TYPES; i++) { LWLock *bktype_lock = &pgStatLocal.shmem->io.locks[i]; - PgStat_BktypeIO *bktype_shstats = &pgStatLocal.shmem->io.stats.stats[i]; + PgStat_BktypeIO *bktype_shstats = &io_stats->stats[i]; LWLockAcquire(bktype_lock, LW_EXCLUSIVE); /* * Use the lock in the first BackendType's PgStat_BktypeIO to protect - * the reset timestamp as well. + * the reset timestamp. */ if (i == 0) - pgStatLocal.shmem->io.stats.stat_reset_timestamp = ts; + io_stats->stat_reset_timestamp = ts; + + /* Reset this BackendType's histogram slots */ + for (int io_object = 0; io_object < IOOBJECT_NUM_TYPES; io_object++) + { + for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++) + { + for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++) + { + int off = bktype_shstats->hist_time_buckets_offsets[io_object][io_context][io_op]; - memset(bktype_shstats, 0, sizeof(*bktype_shstats)); + if (off == -1) + continue; + memset(io_stats->hist_time_buckets_slots[off], 0, + sizeof(io_stats->hist_time_buckets_slots[off])); + } + } + } + + /* Avoid resetting our indirect mapping offsets */ + memset(bktype_shstats, 0, offsetof(PgStat_BktypeIO, hist_time_buckets_offsets)); LWLockRelease(bktype_lock); } } @@ -477,14 +566,30 @@ pgstat_io_reset_all_cb(TimestampTz ts) void pgstat_io_snapshot_cb(void) { + PgStat_IO *shmem_io = &pgStatLocal.shmem->io.stats; + if (unlikely(pgStatLocal.snapshot.io == NULL)) + { + int n = shmem_io->hist_time_buckets_slot_count; + pgStatLocal.snapshot.io = MemoryContextAllocZero(TopMemoryContext, sizeof(PgStat_IO)); + /* + * Allocated on demand in private (TopMemoryContext) memory and points + * to the same indirect offsets. + */ + pgStatLocal.snapshot.io->hist_time_buckets_slot_count = n; + pgStatLocal.snapshot.io->hist_time_buckets_slots = + MemoryContextAllocZero(TopMemoryContext, + (size_t) n * PGSTAT_IO_HIST_BUCKETS * + sizeof(uint64)); + } + for (int i = 0; i < BACKEND_NUM_TYPES; i++) { LWLock *bktype_lock = &pgStatLocal.shmem->io.locks[i]; - PgStat_BktypeIO *bktype_shstats = &pgStatLocal.shmem->io.stats.stats[i]; + PgStat_BktypeIO *bktype_shstats = &shmem_io->stats[i]; PgStat_BktypeIO *bktype_snap = &pgStatLocal.snapshot.io->stats[i]; LWLockAcquire(bktype_lock, LW_SHARED); @@ -495,10 +600,29 @@ pgstat_io_snapshot_cb(void) */ if (i == 0) pgStatLocal.snapshot.io->stat_reset_timestamp = - pgStatLocal.shmem->io.stats.stat_reset_timestamp; + shmem_io->stat_reset_timestamp; /* using struct assignment due to better type safety */ *bktype_snap = *bktype_shstats; + + /* Copy this BackendType's histogram slots */ + for (int io_object = 0; io_object < IOOBJECT_NUM_TYPES; io_object++) + { + for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++) + { + for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++) + { + int off = bktype_shstats->hist_time_buckets_offsets[io_object][io_context][io_op]; + + if (off == -1) + continue; + memcpy(pgStatLocal.snapshot.io->hist_time_buckets_slots[off], + shmem_io->hist_time_buckets_slots[off], + sizeof(shmem_io->hist_time_buckets_slots[off])); + } + } + } + LWLockRelease(bktype_lock); } } @@ -762,3 +886,29 @@ pgstat_tracks_io_op(BackendType bktype, IOObject io_object, return true; } + +/* + * Total number of tuple of really usable combinations (BackendType, IOObject, + * IOContext, IOOp) that we consider trackable. + */ +int +pgstat_io_get_sum_tracked(void) +{ + int sum = 0; + + for (int i = 0; i < BACKEND_NUM_TYPES; i++) + sum += pgstat_bktype_count_potentially_used(i); + + return sum; +} + +/* + * Returns number of bytes for shared memory required by + * PgStat_IO.hist_time_buckets_slots, + */ +Size +pgstat_io_histogram_shmem_size(void) +{ + return mul_size(pgstat_io_get_sum_tracked(), + PGSTAT_IO_HIST_BUCKETS * sizeof(uint64)); +} diff --git a/src/backend/utils/activity/pgstat_shmem.c b/src/backend/utils/activity/pgstat_shmem.c index d8ac9d6f5e8..52f66aa9133 100644 --- a/src/backend/utils/activity/pgstat_shmem.c +++ b/src/backend/utils/activity/pgstat_shmem.c @@ -139,6 +139,12 @@ StatsShmemSize(void) sz = MAXALIGN(sizeof(PgStat_ShmemControl)); sz = add_size(sz, pgstat_dsa_init_size()); + /* + * Dynamic allocation for PgStat_IO.hist_time_buckets_slots. Sized from + * the rules in pgstat_tracks_io_*() + */ + sz = add_size(sz, MAXALIGN(pgstat_io_histogram_shmem_size())); + /* Add shared memory for all the custom fixed-numbered statistics */ for (PgStat_Kind kind = PGSTAT_KIND_CUSTOM_MIN; kind <= PGSTAT_KIND_CUSTOM_MAX; kind++) { @@ -194,6 +200,15 @@ StatsShmemInit(void *arg) LWTRANCHE_PGSTATS_DSA, NULL); dsa_pin(dsa); + /* + * Prepare PgStat_IO.hist_time_buckets_slot* stuff before calling + * pgstat_io_init_shmem_cb(). The additional memory for this was requested + * in the StatsShmemSize() above. + */ + ctl->io.stats.hist_time_buckets_slot_count = pgstat_io_get_sum_tracked(); + ctl->io.stats.hist_time_buckets_slots = (uint64 (*)[PGSTAT_IO_HIST_BUCKETS]) p; + p += MAXALIGN(pgstat_io_histogram_shmem_size()); + /* * To ensure dshash is created in "plain" shared memory, temporarily limit * size of dsa to the initial size of the dsa. diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c index e700089b26d..5dabd388f5d 100644 --- a/src/backend/utils/adt/pgstatfuncs.c +++ b/src/backend/utils/adt/pgstatfuncs.c @@ -1722,12 +1722,14 @@ typedef enum histogram_io_stat_col /* * pg_stat_io_histogram_build_tuples * - * Helper routine for pg_stat_get_io_histogram() and pg_stat_get_backend_io() - * filling a result tuplestore with one tuple for each object and each - * context supported by the caller, based on the contents of bktype_stats. + * Helper routine for pg_stat_get_io_histogram() filling a result tuplestore + * with one tuple per latency bucket for each object, context and I/O + * operation tracked for the given backend type, based on the contents of + * bktype_stats and the histogram slots in backends_io_stats. */ static void pg_stat_io_histogram_build_tuples(ReturnSetInfo *rsinfo, + PgStat_IO *backends_io_stats, PgStat_BktypeIO *bktype_stats, BackendType bktype, TimestampTz stat_reset_timestamp) @@ -1754,6 +1756,16 @@ pg_stat_io_histogram_build_tuples(ReturnSetInfo *rsinfo, for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++) { const char *op_name = pgstat_get_io_op_name(io_op); + int bktype_hist_time_bucket_off; + + /* + * The offset is the same for every histogram bucket of this + * io_obj/io_context/io_op combination. + */ + bktype_hist_time_bucket_off = bktype_stats->hist_time_buckets_offsets[io_obj][io_context][io_op]; + if (bktype_hist_time_bucket_off == -1) + continue; + Assert(bktype_hist_time_bucket_off < backends_io_stats->hist_time_buckets_slot_count); for (int bucket = 0; bucket < PGSTAT_IO_HIST_BUCKETS; bucket++) { @@ -1762,6 +1774,7 @@ pg_stat_io_histogram_build_tuples(ReturnSetInfo *rsinfo, RangeBound lower, upper; RangeType *range; + uint64 bktype_bucket; values[HIST_IO_COL_BACKEND_TYPE] = bktype_desc; values[HIST_IO_COL_OBJECT] = CStringGetTextDatum(obj_name); @@ -1790,9 +1803,9 @@ pg_stat_io_histogram_build_tuples(ReturnSetInfo *rsinfo, range = make_range(typcache, &lower, &upper, false, NULL); values[HIST_IO_COL_BUCKET_US] = RangeTypePGetDatum(range); - /* bucket count */ - values[HIST_IO_COL_COUNT] = Int64GetDatum( - bktype_stats->hist_time_buckets[io_obj][io_context][io_op][bucket]); + /* get bucket count, access indirectly */ + bktype_bucket = backends_io_stats->hist_time_buckets_slots[bktype_hist_time_bucket_off][bucket]; + values[HIST_IO_COL_COUNT] = Int64GetDatum(bktype_bucket); if (stat_reset_timestamp != 0) values[HIST_IO_COL_RESET_TIME] = TimestampTzGetDatum(stat_reset_timestamp); @@ -1838,7 +1851,7 @@ pg_stat_get_io_histogram(PG_FUNCTION_ARGS) continue; /* save tuples with data from this PgStat_BktypeIO */ - pg_stat_io_histogram_build_tuples(rsinfo, bktype_stats, bktype, + pg_stat_io_histogram_build_tuples(rsinfo, backends_io_stats, bktype_stats, bktype, backends_io_stats->stat_reset_timestamp); } diff --git a/src/include/pgstat.h b/src/include/pgstat.h index b917d830e47..b485bf2ec65 100644 --- a/src/include/pgstat.h +++ b/src/include/pgstat.h @@ -377,7 +377,14 @@ typedef struct PgStat_BktypeIO uint64 bytes[IOOBJECT_NUM_TYPES][IOCONTEXT_NUM_TYPES][IOOP_NUM_TYPES]; PgStat_Counter counts[IOOBJECT_NUM_TYPES][IOCONTEXT_NUM_TYPES][IOOP_NUM_TYPES]; PgStat_Counter times[IOOBJECT_NUM_TYPES][IOCONTEXT_NUM_TYPES][IOOP_NUM_TYPES]; - uint64 hist_time_buckets[IOOBJECT_NUM_TYPES][IOCONTEXT_NUM_TYPES][IOOP_NUM_TYPES][PGSTAT_IO_HIST_BUCKETS]; + + /* + * Indirect offset to PgStat_IO (parent + * structure).hist_time_buckets_slots. This needs to be the last field due + * to the use of memset(.., offsetof(hist_time_buckets_offsets)) in + * pgstat_io_reset_all_cb(). + */ + int hist_time_buckets_offsets[IOOBJECT_NUM_TYPES][IOCONTEXT_NUM_TYPES][IOOP_NUM_TYPES]; } PgStat_BktypeIO; typedef struct PgStat_PendingIO @@ -393,7 +400,7 @@ typedef struct PgStat_PendingIO * memory. */ uint64 (*pending_hist_time_buckets)[PGSTAT_IO_HIST_BUCKETS]; - uint64 pending_hist_time_buckets_offsets[IOOBJECT_NUM_TYPES][IOCONTEXT_NUM_TYPES][IOOP_NUM_TYPES]; + int pending_hist_time_buckets_offsets[IOOBJECT_NUM_TYPES][IOCONTEXT_NUM_TYPES][IOOP_NUM_TYPES]; /* * Number of histograms allocated in pending_hist_time_buckets, cached to @@ -407,6 +414,16 @@ typedef struct PgStat_IO { TimestampTz stat_reset_timestamp; PgStat_BktypeIO stats[BACKEND_NUM_TYPES]; + + /* + * The IO histogram memory is sized at postmaster start from the rules in + * pgstat_tracks_io_*() and persisted by additional code to handle this + * dynamic (shared) memory pointer in pgstat_write_statsfile() / + * pgstat_read_statsfile(), so they are not part of the serialization to disk + * by common code. + */ + int hist_time_buckets_slot_count; + uint64 (*hist_time_buckets_slots)[PGSTAT_IO_HIST_BUCKETS]; } PgStat_IO; typedef struct PgStat_LockEntry @@ -713,6 +730,9 @@ extern PgStat_CheckpointerStats *pgstat_fetch_stat_checkpointer(void); extern bool pgstat_bktype_io_stats_valid(PgStat_BktypeIO *backend_io, BackendType bktype); extern int pgstat_bktype_count_potentially_used(BackendType bktype); +extern int pgstat_io_get_sum_tracked(void); +extern int pgstat_io_init_hist_offsets(PgStat_IO *io); +extern Size pgstat_io_histogram_shmem_size(void); extern void pgstat_count_io_op(IOObject io_object, IOContext io_context, IOOp io_op, uint32 cnt, uint64 bytes); extern instr_time pgstat_prepare_io_time(bool track_io_guc); -- 2.43.0