From 5983589a18f286029d1796c3d6363de326ff4463 Mon Sep 17 00:00:00 2001 From: Lukas Fittl Date: Tue, 9 Sep 2025 02:26:56 -0700 Subject: [PATCH v3 7/7] Convert remaining users of pgBufferUsage to use InstrStart/InstrStop, drop the global --- src/backend/access/heap/vacuumlazy.c | 35 ++++++++--------- src/backend/commands/analyze.c | 35 ++++++++--------- src/backend/commands/explain.c | 26 +++++-------- src/backend/commands/explain_dr.c | 31 ++++++++------- src/backend/commands/prepare.c | 26 +++++-------- src/backend/executor/instrument.c | 56 +++++++++++----------------- src/include/executor/instrument.h | 8 +--- 7 files changed, 90 insertions(+), 127 deletions(-) diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index d2b031fdd06..338d540aa01 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -641,8 +641,7 @@ heap_vacuum_rel(Relation rel, const VacuumParams params, TimestampTz starttime = 0; PgStat_Counter startreadtime = 0, startwritetime = 0; - WalUsage startwalusage = pgWalUsage; - BufferUsage startbufferusage = pgBufferUsage; + Instrumentation *instr = NULL; ErrorContextCallback errcallback; char **indnames = NULL; @@ -657,6 +656,8 @@ heap_vacuum_rel(Relation rel, const VacuumParams params, startreadtime = pgStatBlockReadTime; startwritetime = pgStatBlockWriteTime; } + instr = InstrAlloc(1, INSTRUMENT_BUFFERS | INSTRUMENT_WAL); + InstrStart(instr); } /* Used for instrumentation and stats report */ @@ -959,14 +960,14 @@ heap_vacuum_rel(Relation rel, const VacuumParams params, { TimestampTz endtime = GetCurrentTimestamp(); + InstrStop(instr, 0, true); + if (verbose || params.log_vacuum_min_duration == 0 || TimestampDifferenceExceeds(starttime, endtime, params.log_vacuum_min_duration)) { long secs_dur; int usecs_dur; - WalUsage walusage; - BufferUsage bufferusage; StringInfoData buf; char *msgfmt; int32 diff; @@ -977,17 +978,13 @@ heap_vacuum_rel(Relation rel, const VacuumParams params, int64 total_blks_dirtied; TimestampDifference(starttime, endtime, &secs_dur, &usecs_dur); - memset(&walusage, 0, sizeof(WalUsage)); - WalUsageAccumDiff(&walusage, &pgWalUsage, &startwalusage); - memset(&bufferusage, 0, sizeof(BufferUsage)); - BufferUsageAccumDiff(&bufferusage, &pgBufferUsage, &startbufferusage); - - total_blks_hit = bufferusage.shared_blks_hit + - bufferusage.local_blks_hit; - total_blks_read = bufferusage.shared_blks_read + - bufferusage.local_blks_read; - total_blks_dirtied = bufferusage.shared_blks_dirtied + - bufferusage.local_blks_dirtied; + + total_blks_hit = INSTR_GET_BUFUSAGE(instr).shared_blks_hit + + INSTR_GET_BUFUSAGE(instr).local_blks_hit; + total_blks_read = INSTR_GET_BUFUSAGE(instr).shared_blks_read + + INSTR_GET_BUFUSAGE(instr).local_blks_read; + total_blks_dirtied = INSTR_GET_BUFUSAGE(instr).shared_blks_dirtied + + INSTR_GET_BUFUSAGE(instr).local_blks_dirtied; initStringInfo(&buf); if (verbose) @@ -1149,10 +1146,10 @@ heap_vacuum_rel(Relation rel, const VacuumParams params, total_blks_dirtied); appendStringInfo(&buf, _("WAL usage: %" PRId64 " records, %" PRId64 " full page images, %" PRIu64 " bytes, %" PRId64 " buffers full\n"), - walusage.wal_records, - walusage.wal_fpi, - walusage.wal_bytes, - walusage.wal_buffers_full); + INSTR_GET_WALUSAGE(instr).wal_records, + INSTR_GET_WALUSAGE(instr).wal_fpi, + INSTR_GET_WALUSAGE(instr).wal_bytes, + INSTR_GET_WALUSAGE(instr).wal_buffers_full); appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0)); ereport(verbose ? INFO : LOG, diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c index c2e216563c6..92ca59778c7 100644 --- a/src/backend/commands/analyze.c +++ b/src/backend/commands/analyze.c @@ -302,9 +302,7 @@ do_analyze_rel(Relation onerel, const VacuumParams params, Oid save_userid; int save_sec_context; int save_nestlevel; - WalUsage startwalusage = pgWalUsage; - BufferUsage startbufferusage = pgBufferUsage; - BufferUsage bufferusage; + Instrumentation *instr = NULL; PgStat_Counter startreadtime = 0; PgStat_Counter startwritetime = 0; @@ -355,6 +353,9 @@ do_analyze_rel(Relation onerel, const VacuumParams params, } pg_rusage_init(&ru0); + + instr = InstrAlloc(1, INSTRUMENT_BUFFERS | INSTRUMENT_WAL); + InstrStart(instr); } /* Used for instrumentation and stats report */ @@ -735,12 +736,13 @@ do_analyze_rel(Relation onerel, const VacuumParams params, { TimestampTz endtime = GetCurrentTimestamp(); + InstrStop(instr, 0, true); + if (verbose || params.log_analyze_min_duration == 0 || TimestampDifferenceExceeds(starttime, endtime, params.log_analyze_min_duration)) { long delay_in_ms; - WalUsage walusage; double read_rate = 0; double write_rate = 0; char *msgfmt; @@ -749,17 +751,12 @@ do_analyze_rel(Relation onerel, const VacuumParams params, int64 total_blks_read; int64 total_blks_dirtied; - memset(&bufferusage, 0, sizeof(BufferUsage)); - BufferUsageAccumDiff(&bufferusage, &pgBufferUsage, &startbufferusage); - memset(&walusage, 0, sizeof(WalUsage)); - WalUsageAccumDiff(&walusage, &pgWalUsage, &startwalusage); - - total_blks_hit = bufferusage.shared_blks_hit + - bufferusage.local_blks_hit; - total_blks_read = bufferusage.shared_blks_read + - bufferusage.local_blks_read; - total_blks_dirtied = bufferusage.shared_blks_dirtied + - bufferusage.local_blks_dirtied; + total_blks_hit = INSTR_GET_BUFUSAGE(instr).shared_blks_hit + + INSTR_GET_BUFUSAGE(instr).local_blks_hit; + total_blks_read = INSTR_GET_BUFUSAGE(instr).shared_blks_read + + INSTR_GET_BUFUSAGE(instr).local_blks_read; + total_blks_dirtied = INSTR_GET_BUFUSAGE(instr).shared_blks_dirtied + + INSTR_GET_BUFUSAGE(instr).local_blks_dirtied; /* * We do not expect an analyze to take > 25 days and it simplifies @@ -832,10 +829,10 @@ do_analyze_rel(Relation onerel, const VacuumParams params, total_blks_dirtied); appendStringInfo(&buf, _("WAL usage: %" PRId64 " records, %" PRId64 " full page images, %" PRIu64 " bytes, %" PRId64 " buffers full\n"), - walusage.wal_records, - walusage.wal_fpi, - walusage.wal_bytes, - walusage.wal_buffers_full); + INSTR_GET_WALUSAGE(instr).wal_records, + INSTR_GET_WALUSAGE(instr).wal_fpi, + INSTR_GET_WALUSAGE(instr).wal_bytes, + INSTR_GET_WALUSAGE(instr).wal_buffers_full); appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0)); ereport(verbose ? INFO : LOG, diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c index bb0689b95d4..4a396575bae 100644 --- a/src/backend/commands/explain.c +++ b/src/backend/commands/explain.c @@ -322,14 +322,16 @@ standard_ExplainOneQuery(Query *query, int cursorOptions, QueryEnvironment *queryEnv) { PlannedStmt *plan; - instr_time planstart, - planduration; - BufferUsage bufusage_start, - bufusage; + Instrumentation *instr = NULL; MemoryContextCounters mem_counters; MemoryContext planner_ctx = NULL; MemoryContext saved_ctx = NULL; + if (es->buffers) + instr = InstrAlloc(1, INSTRUMENT_TIMER | INSTRUMENT_BUFFERS); + else + instr = InstrAlloc(1, INSTRUMENT_TIMER); + if (es->memory) { /* @@ -346,15 +348,12 @@ standard_ExplainOneQuery(Query *query, int cursorOptions, saved_ctx = MemoryContextSwitchTo(planner_ctx); } - if (es->buffers) - bufusage_start = pgBufferUsage; - INSTR_TIME_SET_CURRENT(planstart); + InstrStart(instr); /* plan the query */ plan = pg_plan_query(query, queryString, cursorOptions, params, es); - INSTR_TIME_SET_CURRENT(planduration); - INSTR_TIME_SUBTRACT(planduration, planstart); + InstrStop(instr, 0, true); if (es->memory) { @@ -362,16 +361,9 @@ standard_ExplainOneQuery(Query *query, int cursorOptions, MemoryContextMemConsumed(planner_ctx, &mem_counters); } - /* calc differences of buffer counters. */ - if (es->buffers) - { - memset(&bufusage, 0, sizeof(BufferUsage)); - BufferUsageAccumDiff(&bufusage, &pgBufferUsage, &bufusage_start); - } - /* run it (if needed) and produce output */ ExplainOnePlan(plan, into, es, queryString, params, queryEnv, - &planduration, (es->buffers ? &bufusage : NULL), + &instr->total, (es->buffers ? &INSTR_GET_BUFUSAGE(instr) : NULL), es->memory ? &mem_counters : NULL); } diff --git a/src/backend/commands/explain_dr.c b/src/backend/commands/explain_dr.c index 95685d7e88d..9fa0b51e62a 100644 --- a/src/backend/commands/explain_dr.c +++ b/src/backend/commands/explain_dr.c @@ -110,15 +110,20 @@ serializeAnalyzeReceive(TupleTableSlot *slot, DestReceiver *self) MemoryContext oldcontext; StringInfo buf = &myState->buf; int natts = typeinfo->natts; - instr_time start, - end; - BufferUsage instr_start; + Instrumentation *instr = NULL; /* only measure time, buffers if requested */ - if (myState->es->timing) - INSTR_TIME_SET_CURRENT(start); - if (myState->es->buffers) - instr_start = pgBufferUsage; + if (myState->es->timing || myState->es->buffers) + { + InstrumentOption instrument_options = 0; + + if (myState->es->timing) + instrument_options |= INSTRUMENT_TIMER; + if (myState->es->buffers) + instrument_options |= INSTRUMENT_BUFFERS; + instr = InstrAlloc(1, instrument_options); + InstrStart(instr); + } /* Set or update my derived attribute info, if needed */ if (myState->attrinfo != typeinfo || myState->nattrs != natts) @@ -186,18 +191,16 @@ serializeAnalyzeReceive(TupleTableSlot *slot, DestReceiver *self) MemoryContextSwitchTo(oldcontext); MemoryContextReset(myState->tmpcontext); + if (myState->es->timing || myState->es->buffers) + InstrStop(instr, 0, true); + /* Update timing data */ if (myState->es->timing) - { - INSTR_TIME_SET_CURRENT(end); - INSTR_TIME_ACCUM_DIFF(myState->metrics.timeSpent, end, start); - } + INSTR_TIME_ADD(myState->metrics.timeSpent, instr->total); /* Update buffer metrics */ if (myState->es->buffers) - BufferUsageAccumDiff(&myState->metrics.bufferUsage, - &pgBufferUsage, - &instr_start); + BufferUsageAdd(&myState->metrics.bufferUsage, &INSTR_GET_BUFUSAGE(instr)); return true; } diff --git a/src/backend/commands/prepare.c b/src/backend/commands/prepare.c index 34b6410d6a2..d92aeb6a1df 100644 --- a/src/backend/commands/prepare.c +++ b/src/backend/commands/prepare.c @@ -578,14 +578,16 @@ ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, ListCell *p; ParamListInfo paramLI = NULL; EState *estate = NULL; - instr_time planstart; - instr_time planduration; - BufferUsage bufusage_start, - bufusage; + Instrumentation *instr = NULL; MemoryContextCounters mem_counters; MemoryContext planner_ctx = NULL; MemoryContext saved_ctx = NULL; + if (es->buffers) + instr = InstrAlloc(1, INSTRUMENT_TIMER | INSTRUMENT_BUFFERS); + else + instr = InstrAlloc(1, INSTRUMENT_TIMER); + if (es->memory) { /* See ExplainOneQuery about this */ @@ -596,9 +598,7 @@ ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, saved_ctx = MemoryContextSwitchTo(planner_ctx); } - if (es->buffers) - bufusage_start = pgBufferUsage; - INSTR_TIME_SET_CURRENT(planstart); + InstrStart(instr); /* Look it up in the hash table */ entry = FetchPreparedStatement(execstmt->name, true); @@ -633,8 +633,7 @@ ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, cplan = GetCachedPlan(entry->plansource, paramLI, CurrentResourceOwner, pstate->p_queryEnv); - INSTR_TIME_SET_CURRENT(planduration); - INSTR_TIME_SUBTRACT(planduration, planstart); + InstrStop(instr, 0, true); if (es->memory) { @@ -642,13 +641,6 @@ ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, MemoryContextMemConsumed(planner_ctx, &mem_counters); } - /* calc differences of buffer counters. */ - if (es->buffers) - { - memset(&bufusage, 0, sizeof(BufferUsage)); - BufferUsageAccumDiff(&bufusage, &pgBufferUsage, &bufusage_start); - } - plan_list = cplan->stmt_list; /* Explain each query */ @@ -658,7 +650,7 @@ ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, if (pstmt->commandType != CMD_UTILITY) ExplainOnePlan(pstmt, into, es, query_string, paramLI, pstate->p_queryEnv, - &planduration, (es->buffers ? &bufusage : NULL), + &instr->total, (es->buffers ? &INSTR_GET_BUFUSAGE(instr) : NULL), es->memory ? &mem_counters : NULL); else ExplainOneUtility(pstmt->utilityStmt, into, es, pstate, paramLI); diff --git a/src/backend/executor/instrument.c b/src/backend/executor/instrument.c index d5fdbecb025..d61830a7fd8 100644 --- a/src/backend/executor/instrument.c +++ b/src/backend/executor/instrument.c @@ -18,11 +18,9 @@ #include "executor/instrument.h" #include "utils/memutils.h" -BufferUsage pgBufferUsage; WalUsage pgWalUsage; InstrStack *pgInstrStack = NULL; -static void BufferUsageAdd(BufferUsage *dst, const BufferUsage *add); static void WalUsageAdd(WalUsage *dst, WalUsage *add); /* @@ -113,6 +111,27 @@ ResOwnerReleaseInstrumentation(Datum res) instr->finalized = true; } +InstrStack * +InstrPushStack() +{ + InstrStack *stack = palloc0(sizeof(InstrStack)); + + stack->previous = pgInstrStack; + pgInstrStack = stack; + + return stack; +} + +void +InstrPopStack(InstrStack * stack) +{ + Assert(stack != NULL); + + pgInstrStack = stack->previous; + if (pgInstrStack) + InstrStackAdd(pgInstrStack, stack); +} + /* General purpose instrumentation handling */ Instrumentation * InstrAlloc(int n, int instrument_options) @@ -393,12 +412,11 @@ InstrAccumParallelQuery(BufferUsage *bufusage, WalUsage *walusage) WalUsageAdd(&dst->walusage, walusage); } - BufferUsageAdd(&pgBufferUsage, bufusage); WalUsageAdd(&pgWalUsage, walusage); } /* dst += add */ -static void +void BufferUsageAdd(BufferUsage *dst, const BufferUsage *add) { dst->shared_blks_hit += add->shared_blks_hit; @@ -419,36 +437,6 @@ BufferUsageAdd(BufferUsage *dst, const BufferUsage *add) INSTR_TIME_ADD(dst->temp_blk_write_time, add->temp_blk_write_time); } -/* dst += add - sub */ -void -BufferUsageAccumDiff(BufferUsage *dst, - const BufferUsage *add, - const BufferUsage *sub) -{ - dst->shared_blks_hit += add->shared_blks_hit - sub->shared_blks_hit; - dst->shared_blks_read += add->shared_blks_read - sub->shared_blks_read; - dst->shared_blks_dirtied += add->shared_blks_dirtied - sub->shared_blks_dirtied; - dst->shared_blks_written += add->shared_blks_written - sub->shared_blks_written; - dst->local_blks_hit += add->local_blks_hit - sub->local_blks_hit; - dst->local_blks_read += add->local_blks_read - sub->local_blks_read; - dst->local_blks_dirtied += add->local_blks_dirtied - sub->local_blks_dirtied; - dst->local_blks_written += add->local_blks_written - sub->local_blks_written; - dst->temp_blks_read += add->temp_blks_read - sub->temp_blks_read; - dst->temp_blks_written += add->temp_blks_written - sub->temp_blks_written; - INSTR_TIME_ACCUM_DIFF(dst->shared_blk_read_time, - add->shared_blk_read_time, sub->shared_blk_read_time); - INSTR_TIME_ACCUM_DIFF(dst->shared_blk_write_time, - add->shared_blk_write_time, sub->shared_blk_write_time); - INSTR_TIME_ACCUM_DIFF(dst->local_blk_read_time, - add->local_blk_read_time, sub->local_blk_read_time); - INSTR_TIME_ACCUM_DIFF(dst->local_blk_write_time, - add->local_blk_write_time, sub->local_blk_write_time); - INSTR_TIME_ACCUM_DIFF(dst->temp_blk_read_time, - add->temp_blk_read_time, sub->temp_blk_read_time); - INSTR_TIME_ACCUM_DIFF(dst->temp_blk_write_time, - add->temp_blk_write_time, sub->temp_blk_write_time); -} - /* helper functions for WAL usage accumulation */ static void WalUsageAdd(WalUsage *dst, WalUsage *add) diff --git a/src/include/executor/instrument.h b/src/include/executor/instrument.h index 8804ee64311..e45c452bc79 100644 --- a/src/include/executor/instrument.h +++ b/src/include/executor/instrument.h @@ -139,7 +139,6 @@ typedef struct WorkerInstrumentation NodeInstrumentation instrument[FLEXIBLE_ARRAY_MEMBER]; } WorkerInstrumentation; -extern PGDLLIMPORT BufferUsage pgBufferUsage; extern PGDLLIMPORT WalUsage pgWalUsage; extern PGDLLIMPORT InstrStack * pgInstrStack; @@ -162,9 +161,8 @@ extern void InstrAggNode(NodeInstrumentation * dst, NodeInstrumentation * add); extern Instrumentation *InstrStartParallelQuery(void); extern void InstrEndParallelQuery(Instrumentation *instr, BufferUsage *bufusage, WalUsage *walusage); extern void InstrAccumParallelQuery(BufferUsage *bufusage, WalUsage *walusage); -extern void BufferUsageAccumDiff(BufferUsage *dst, - const BufferUsage *add, const BufferUsage *sub); extern void InstrStackAdd(InstrStack * dst, InstrStack * add); +extern void BufferUsageAdd(BufferUsage *dst, const BufferUsage *add); extern void WalUsageAccumDiff(WalUsage *dst, const WalUsage *add, const WalUsage *sub); @@ -175,22 +173,18 @@ extern void WalUsageAccumDiff(WalUsage *dst, const WalUsage *add, instr->stack.walusage #define INSTR_BUFUSAGE_INCR(fld) do { \ - pgBufferUsage.fld++; \ if (pgInstrStack) \ pgInstrStack->bufusage.fld++; \ } while(0) #define INSTR_BUFUSAGE_ADD(fld,val) do { \ - pgBufferUsage.fld += val; \ if (pgInstrStack) \ pgInstrStack->bufusage.fld += val; \ } while(0) #define INSTR_BUFUSAGE_TIME_ADD(fld,val) do { \ - INSTR_TIME_ADD(pgBufferUsage.fld, val); \ if (pgInstrStack) \ INSTR_TIME_ADD(pgInstrStack->bufusage.fld, val); \ } while (0) #define INSTR_BUFUSAGE_TIME_ACCUM_DIFF(fld,endval,startval) do { \ - INSTR_TIME_ACCUM_DIFF(pgBufferUsage.fld, endval, startval); \ if (pgInstrStack) \ INSTR_TIME_ACCUM_DIFF(pgInstrStack->bufusage.fld, endval, startval); \ } while (0) -- 2.47.1