Debian Codegraph @

src/backend/utils/activity/pgstat_backend.c

raw
1 /* -------------------------------------------------------------------------
2 *
3 * pgstat_backend.c
4 * Implementation of backend statistics.
5 *
6 * This file contains the implementation of backend statistics. It is kept
7 * separate from pgstat.c to enforce the line between the statistics access /
8 * storage implementation and the details about individual types of
9 * statistics.
10 *
11 * This statistics kind uses a proc number as object ID for the hash table
12 * of pgstats. Entries are created each time a process is spawned, and are
13 * dropped when the process exits. These are not written to the pgstats file
14 * on disk. Pending statistics are managed without direct interactions with
15 * PgStat_EntryRef->pending, relying on PendingBackendStats instead so as it
16 * is possible to report data within critical sections.
17 *
18 * Copyright (c) 2001-2025, PostgreSQL Global Development Group
19 *
20 * IDENTIFICATION
21 * src/backend/utils/activity/pgstat_backend.c
22 * -------------------------------------------------------------------------
23 */
24
25 #include "postgres.h"
26
27 #include "access/xlog.h"
28 #include "executor/instrument.h"
29 #include "storage/bufmgr.h"
30 #include "storage/proc.h"
31 #include "storage/procarray.h"
32 #include "utils/memutils.h"
33 #include "utils/pgstat_internal.h"
34
35 /*
36 * Backend statistics counts waiting to be flushed out. These counters may be
37 * reported within critical sections so we use static memory in order to avoid
38 * memory allocation.
39 */
40 static PgStat_BackendPending PendingBackendStats;
41 static bool backend_has_iostats = false;
42
43 /*
44 * WAL usage counters saved from pgWalUsage at the previous call to
45 * pgstat_flush_backend(). This is used to calculate how much WAL usage
46 * happens between pgstat_flush_backend() calls, by subtracting the
47 * previous counters from the current ones.
48 */
49 static WalUsage prevBackendWalUsage;
50
51 /*
52 * Utility routines to report I/O stats for backends, kept here to avoid
53 * exposing PendingBackendStats to the outside world.
54 */
55 void
56 pgstat_count_backend_io_op_time(IOObject io_object, IOContext io_context,
57 IOOp io_op, instr_time io_time)
58 {
59 Assert(track_io_timing || track_wal_io_timing);
60
61 if (!pgstat_tracks_backend_bktype(MyBackendType))
62 return;
63
64 Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
65
66 INSTR_TIME_ADD(PendingBackendStats.pending_io.pending_times[io_object][io_context][io_op],
67 io_time);
68
69 backend_has_iostats = true;
70 pgstat_report_fixed = true;
71 }
72
73 void
74 pgstat_count_backend_io_op(IOObject io_object, IOContext io_context,
75 IOOp io_op, uint32 cnt, uint64 bytes)
76 {
77 if (!pgstat_tracks_backend_bktype(MyBackendType))
78 return;
79
80 Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
81
82 PendingBackendStats.pending_io.counts[io_object][io_context][io_op] += cnt;
83 PendingBackendStats.pending_io.bytes[io_object][io_context][io_op] += bytes;
84
85 backend_has_iostats = true;
86 pgstat_report_fixed = true;
87 }
88
89 /*
90 * Returns statistics of a backend by proc number.
91 */
92 PgStat_Backend *
93 pgstat_fetch_stat_backend(ProcNumber procNumber)
94 {
95 PgStat_Backend *backend_entry;
96
97 backend_entry = (PgStat_Backend *) pgstat_fetch_entry(PGSTAT_KIND_BACKEND,
98 InvalidOid, procNumber);
99
100 return backend_entry;
101 }
102
103 /*
104 * Returns statistics of a backend by pid.
105 *
106 * This routine includes sanity checks to ensure that the backend exists and
107 * is running. "bktype" can be optionally defined to return the BackendType
108 * of the backend whose statistics are returned.
109 */
110 PgStat_Backend *
111 pgstat_fetch_stat_backend_by_pid(int pid, BackendType *bktype)
112 {
113 PGPROC *proc;
114 PgBackendStatus *beentry;
115 ProcNumber procNumber;
116 PgStat_Backend *backend_stats;
117
118 proc = BackendPidGetProc(pid);
119 if (bktype)
120 *bktype = B_INVALID;
121
122 /* this could be an auxiliary process */
123 if (!proc)
124 proc = AuxiliaryPidGetProc(pid);
125
126 if (!proc)
127 return NULL;
128
129 procNumber = GetNumberFromPGProc(proc);
130
131 beentry = pgstat_get_beentry_by_proc_number(procNumber);
132 if (!beentry)
133 return NULL;
134
135 /* check if the backend type tracks statistics */
136 if (!pgstat_tracks_backend_bktype(beentry->st_backendType))
137 return NULL;
138
139 /* if PID does not match, leave */
140 if (beentry->st_procpid != pid)
141 return NULL;
142
143 if (bktype)
144 *bktype = beentry->st_backendType;
145
146 /*
147 * Retrieve the entry. Note that "beentry" may be freed depending on the
148 * value of stats_fetch_consistency, so do not access it from this point.
149 */
150 backend_stats = pgstat_fetch_stat_backend(procNumber);
151 if (!backend_stats)
152 {
153 if (bktype)
154 *bktype = B_INVALID;
155 return NULL;
156 }
157
158 return backend_stats;
159 }
160
161 /*
162 * Flush out locally pending backend IO statistics. Locking is managed
163 * by the caller.
164 */
165 static void
166 pgstat_flush_backend_entry_io(PgStat_EntryRef *entry_ref)
167 {
168 PgStatShared_Backend *shbackendent;
169 PgStat_BktypeIO *bktype_shstats;
170 PgStat_PendingIO pending_io;
171
172 /*
173 * This function can be called even if nothing at all has happened for IO
174 * statistics. In this case, avoid unnecessarily modifying the stats
175 * entry.
176 */
177 if (!backend_has_iostats)
178 return;
179
180 shbackendent = (PgStatShared_Backend *) entry_ref->shared_stats;
181 bktype_shstats = &shbackendent->stats.io_stats;
182 pending_io = PendingBackendStats.pending_io;
183
184 for (int io_object = 0; io_object < IOOBJECT_NUM_TYPES; io_object++)
185 {
186 for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++)
187 {
188 for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++)
189 {
190 instr_time time;
191
192 bktype_shstats->counts[io_object][io_context][io_op] +=
193 pending_io.counts[io_object][io_context][io_op];
194 bktype_shstats->bytes[io_object][io_context][io_op] +=
195 pending_io.bytes[io_object][io_context][io_op];
196 time = pending_io.pending_times[io_object][io_context][io_op];
197
198 bktype_shstats->times[io_object][io_context][io_op] +=
199 INSTR_TIME_GET_MICROSEC(time);
200 }
201 }
202 }
203
204 /*
205 * Clear out the statistics buffer, so it can be re-used.
206 */
207 MemSet(&PendingBackendStats.pending_io, 0, sizeof(PgStat_PendingIO));
208
209 backend_has_iostats = false;
210 }
211
212 /*
213 * To determine whether WAL usage happened.
214 */
215 static inline bool
216 pgstat_backend_wal_have_pending(void)
217 {
218 return (pgWalUsage.wal_records != prevBackendWalUsage.wal_records);
219 }
220
221 /*
222 * Flush out locally pending backend WAL statistics. Locking is managed
223 * by the caller.
224 */
225 static void
226 pgstat_flush_backend_entry_wal(PgStat_EntryRef *entry_ref)
227 {
228 PgStatShared_Backend *shbackendent;
229 PgStat_WalCounters *bktype_shstats;
230 WalUsage wal_usage_diff = {0};
231
232 /*
233 * This function can be called even if nothing at all has happened for WAL
234 * statistics. In this case, avoid unnecessarily modifying the stats
235 * entry.
236 */
237 if (!pgstat_backend_wal_have_pending())
238 return;
239
240 shbackendent = (PgStatShared_Backend *) entry_ref->shared_stats;
241 bktype_shstats = &shbackendent->stats.wal_counters;
242
243 /*
244 * Calculate how much WAL usage counters were increased by subtracting the
245 * previous counters from the current ones.
246 */
247 WalUsageAccumDiff(&wal_usage_diff, &pgWalUsage, &prevBackendWalUsage);
248
249 #define WALSTAT_ACC(fld, var_to_add) \
250 (bktype_shstats->fld += var_to_add.fld)
251 WALSTAT_ACC(wal_buffers_full, wal_usage_diff);
252 WALSTAT_ACC(wal_records, wal_usage_diff);
253 WALSTAT_ACC(wal_fpi, wal_usage_diff);
254 WALSTAT_ACC(wal_bytes, wal_usage_diff);
255 #undef WALSTAT_ACC
256
257 /*
258 * Save the current counters for the subsequent calculation of WAL usage.
259 */
260 prevBackendWalUsage = pgWalUsage;
261 }
262
263 /*
264 * Flush out locally pending backend statistics
265 *
266 * "flags" parameter controls which statistics to flush. Returns true
267 * if some statistics could not be flushed due to lock contention.
268 */
269 bool
270 pgstat_flush_backend(bool nowait, bits32 flags)
271 {
272 PgStat_EntryRef *entry_ref;
273 bool has_pending_data = false;
274
275 if (!pgstat_tracks_backend_bktype(MyBackendType))
276 return false;
277
278 /* Some IO data pending? */
279 if ((flags & PGSTAT_BACKEND_FLUSH_IO) && backend_has_iostats)
280 has_pending_data = true;
281
282 /* Some WAL data pending? */
283 if ((flags & PGSTAT_BACKEND_FLUSH_WAL) &&
284 pgstat_backend_wal_have_pending())
285 has_pending_data = true;
286
287 if (!has_pending_data)
288 return false;
289
290 entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_BACKEND, InvalidOid,
291 MyProcNumber, nowait);
292 if (!entry_ref)
293 return true;
294
295 /* Flush requested statistics */
296 if (flags & PGSTAT_BACKEND_FLUSH_IO)
297 pgstat_flush_backend_entry_io(entry_ref);
298
299 if (flags & PGSTAT_BACKEND_FLUSH_WAL)
300 pgstat_flush_backend_entry_wal(entry_ref);
301
302 pgstat_unlock_entry(entry_ref);
303
304 return false;
305 }
306
307 /*
308 * Callback to flush out locally pending backend statistics.
309 *
310 * If some stats could not be flushed due to lock contention, return true.
311 */
312 bool
313 pgstat_backend_flush_cb(bool nowait)
314 {
315 return pgstat_flush_backend(nowait, PGSTAT_BACKEND_FLUSH_ALL);
316 }
317
318 /*
319 * Create backend statistics entry for proc number.
320 */
321 void
322 pgstat_create_backend(ProcNumber procnum)
323 {
324 PgStat_EntryRef *entry_ref;
325 PgStatShared_Backend *shstatent;
326
327 entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_BACKEND, InvalidOid,
328 procnum, false);
329 shstatent = (PgStatShared_Backend *) entry_ref->shared_stats;
330
331 /*
332 * NB: need to accept that there might be stats from an older backend,
333 * e.g. if we previously used this proc number.
334 */
335 memset(&shstatent->stats, 0, sizeof(shstatent->stats));
336 pgstat_unlock_entry(entry_ref);
337
338 MemSet(&PendingBackendStats, 0, sizeof(PgStat_BackendPending));
339 backend_has_iostats = false;
340
341 /*
342 * Initialize prevBackendWalUsage with pgWalUsage so that
343 * pgstat_backend_flush_cb() can calculate how much pgWalUsage counters
344 * are increased by subtracting prevBackendWalUsage from pgWalUsage.
345 */
346 prevBackendWalUsage = pgWalUsage;
347 }
348
349 /*
350 * Backend statistics are not collected for all BackendTypes.
351 *
352 * The following BackendTypes do not participate in the backend stats
353 * subsystem:
354 * - The same and for the same reasons as in pgstat_tracks_io_bktype().
355 * - B_BG_WRITER, B_CHECKPOINTER, B_STARTUP and B_AUTOVAC_LAUNCHER because their
356 * I/O stats are already visible in pg_stat_io and there is only one of those.
357 *
358 * Function returns true if BackendType participates in the backend stats
359 * subsystem and false if it does not.
360 *
361 * When adding a new BackendType, also consider adding relevant restrictions to
362 * pgstat_tracks_io_object() and pgstat_tracks_io_op().
363 */
364 bool
365 pgstat_tracks_backend_bktype(BackendType bktype)
366 {
367 /*
368 * List every type so that new backend types trigger a warning about
369 * needing to adjust this switch.
370 */
371 switch (bktype)
372 {
373 case B_INVALID:
374 case B_AUTOVAC_LAUNCHER:
375 case B_DEAD_END_BACKEND:
376 case B_ARCHIVER:
377 case B_LOGGER:
378 case B_BG_WRITER:
379 case B_CHECKPOINTER:
380 case B_IO_WORKER:
381 case B_STARTUP:
382 return false;
383
384 case B_AUTOVAC_WORKER:
385 case B_BACKEND:
386 case B_BG_WORKER:
387 case B_STANDALONE_BACKEND:
388 case B_SLOTSYNC_WORKER:
389 case B_WAL_RECEIVER:
390 case B_WAL_SENDER:
391 case B_WAL_SUMMARIZER:
392 case B_WAL_WRITER:
393 return true;
394 }
395
396 return false;
397 }
398
399 void
400 pgstat_backend_reset_timestamp_cb(PgStatShared_Common *header, TimestampTz ts)
401 {
402 ((PgStatShared_Backend *) header)->stats.stat_reset_timestamp = ts;
403 }