Line data Source code
1 : /* ----------
2 : * pgstat_internal.h
3 : *
4 : * Definitions for the PostgreSQL cumulative statistics system that should
5 : * only be needed by files implementing statistics support (rather than ones
6 : * reporting / querying stats).
7 : *
8 : * Copyright (c) 2001-2025, PostgreSQL Global Development Group
9 : *
10 : * src/include/utils/pgstat_internal.h
11 : * ----------
12 : */
13 : #ifndef PGSTAT_INTERNAL_H
14 : #define PGSTAT_INTERNAL_H
15 :
16 :
17 : #include "common/hashfn_unstable.h"
18 : #include "lib/dshash.h"
19 : #include "lib/ilist.h"
20 : #include "pgstat.h"
21 : #include "storage/lwlock.h"
22 : #include "utils/dsa.h"
23 :
24 :
25 : /*
26 : * Types related to shared memory storage of statistics.
27 : *
28 : * Per-object statistics are stored in the "shared stats" hashtable. That
29 : * table's entries (PgStatShared_HashEntry) contain a pointer to the actual stats
30 : * data for the object (the size of the stats data varies depending on the
31 : * kind of stats). The table is keyed by PgStat_HashKey.
32 : *
33 : * Once a backend has a reference to a shared stats entry, it increments the
34 : * entry's refcount. Even after stats data is dropped (e.g., due to a DROP
35 : * TABLE), the entry itself can only be deleted once all references have been
36 : * released.
37 : *
38 : * These refcounts, in combination with a backend local hashtable
39 : * (pgStatEntryRefHash, with entries pointing to PgStat_EntryRef) in front of
40 : * the shared hash table, mean that most stats work can happen without
41 : * touching the shared hash table, reducing contention.
42 : *
43 : * Once there are pending stats updates for a table PgStat_EntryRef->pending
44 : * is allocated to contain a working space for as-of-yet-unapplied stats
45 : * updates. Once the stats are flushed, PgStat_EntryRef->pending is freed.
46 : *
47 : * Each stat kind in the shared hash table has a fixed member
48 : * PgStatShared_Common as the first element.
49 : */
50 :
51 : /* struct for shared statistics hash entry key. */
52 : typedef struct PgStat_HashKey
53 : {
54 : PgStat_Kind kind; /* statistics entry kind */
55 : Oid dboid; /* database ID. InvalidOid for shared objects. */
56 : uint64 objid; /* object ID (table, function, etc.), or
57 : * identifier. */
58 : } PgStat_HashKey;
59 :
60 : /*
61 : * Shared statistics hash entry. Doesn't itself contain any stats, but points
62 : * to them (with ->body). That allows the stats entries themselves to be of
63 : * variable size.
64 : */
65 : typedef struct PgStatShared_HashEntry
66 : {
67 : PgStat_HashKey key; /* hash key */
68 :
69 : /*
70 : * If dropped is set, backends need to release their references so that
71 : * the memory for the entry can be freed. No new references may be made
72 : * once marked as dropped.
73 : */
74 : bool dropped;
75 :
76 : /*
77 : * Refcount managing lifetime of the entry itself (as opposed to the
78 : * dshash entry pointing to it). The stats lifetime has to be separate
79 : * from the hash table entry lifetime because we allow backends to point
80 : * to a stats entry without holding a hash table lock (and some other
81 : * reasons).
82 : *
83 : * As long as the entry is not dropped, 1 is added to the refcount
84 : * representing that the entry should not be dropped. In addition each
85 : * backend that has a reference to the entry needs to increment the
86 : * refcount as long as it does.
87 : *
88 : * May only be incremented / decremented while holding at least a shared
89 : * lock on the dshash partition containing the entry. It needs to be an
90 : * atomic variable because multiple backends can increment the refcount
91 : * with just a shared lock.
92 : *
93 : * When the refcount reaches 0 the entry needs to be freed.
94 : */
95 : pg_atomic_uint32 refcount;
96 :
97 : /*
98 : * Counter tracking the number of times the entry has been reused.
99 : *
100 : * Set to 0 when the entry is created, and incremented by one each time
101 : * the shared entry is reinitialized with pgstat_reinit_entry().
102 : *
103 : * May only be incremented / decremented while holding at least a shared
104 : * lock on the dshash partition containing the entry. Like refcount, it
105 : * needs to be an atomic variable because multiple backends can increment
106 : * the generation with just a shared lock.
107 : */
108 : pg_atomic_uint32 generation;
109 :
110 : /*
111 : * Pointer to shared stats. The stats entry always starts with
112 : * PgStatShared_Common, embedded in a larger struct containing the
113 : * PgStat_Kind specific stats fields.
114 : */
115 : dsa_pointer body;
116 : } PgStatShared_HashEntry;
117 :
118 : /*
119 : * Common header struct for PgStatShared_*.
120 : */
121 : typedef struct PgStatShared_Common
122 : {
123 : uint32 magic; /* just a validity cross-check */
124 : /* lock protecting stats contents (i.e. data following the header) */
125 : LWLock lock;
126 : } PgStatShared_Common;
127 :
128 : /*
129 : * A backend local reference to a shared stats entry. As long as at least one
130 : * such reference exists, the shared stats entry will not be released.
131 : *
132 : * If there are pending stats update to the shared stats, these are stored in
133 : * ->pending.
134 : */
135 : typedef struct PgStat_EntryRef
136 : {
137 : /*
138 : * Pointer to the PgStatShared_HashEntry entry in the shared stats
139 : * hashtable.
140 : */
141 : PgStatShared_HashEntry *shared_entry;
142 :
143 : /*
144 : * Pointer to the stats data (i.e. PgStatShared_HashEntry->body), resolved
145 : * as a local pointer, to avoid repeated dsa_get_address() calls.
146 : */
147 : PgStatShared_Common *shared_stats;
148 :
149 : /*
150 : * Copy of PgStatShared_HashEntry->generation, keeping locally track of
151 : * the shared stats entry "generation" retrieved (number of times reused).
152 : */
153 : uint32 generation;
154 :
155 : /*
156 : * Pending statistics data that will need to be flushed to shared memory
157 : * stats eventually. Each stats kind utilizing pending data defines what
158 : * format its pending data has and needs to provide a
159 : * PgStat_KindInfo->flush_pending_cb callback to merge pending entries
160 : * into the shared stats hash table.
161 : */
162 : void *pending;
163 : dlist_node pending_node; /* membership in pgStatPending list */
164 : } PgStat_EntryRef;
165 :
166 :
167 : /*
168 : * Some stats changes are transactional. To maintain those, a stack of
169 : * PgStat_SubXactStatus entries is maintained, which contain data pertaining
170 : * to the current transaction and its active subtransactions.
171 : */
172 : typedef struct PgStat_SubXactStatus
173 : {
174 : int nest_level; /* subtransaction nest level */
175 :
176 : struct PgStat_SubXactStatus *prev; /* higher-level subxact if any */
177 :
178 : /*
179 : * Statistics for transactionally dropped objects need to be
180 : * transactionally dropped as well. Collect the stats dropped in the
181 : * current (sub-)transaction and only execute the stats drop when we know
182 : * if the transaction commits/aborts. To handle replicas and crashes,
183 : * stats drops are included in commit / abort records.
184 : */
185 : dclist_head pending_drops;
186 :
187 : /*
188 : * Tuple insertion/deletion counts for an open transaction can't be
189 : * propagated into PgStat_TableStatus counters until we know if it is
190 : * going to commit or abort. Hence, we keep these counts in per-subxact
191 : * structs that live in TopTransactionContext. This data structure is
192 : * designed on the assumption that subxacts won't usually modify very many
193 : * tables.
194 : */
195 : PgStat_TableXactStatus *first; /* head of list for this subxact */
196 : } PgStat_SubXactStatus;
197 :
198 :
199 : /*
200 : * Metadata for a specific kind of statistics.
201 : */
202 : typedef struct PgStat_KindInfo
203 : {
204 : /*
205 : * Do a fixed number of stats objects exist for this kind of stats (e.g.
206 : * bgwriter stats) or not (e.g. tables).
207 : */
208 : bool fixed_amount:1;
209 :
210 : /*
211 : * Can stats of this kind be accessed from another database? Determines
212 : * whether a stats object gets included in stats snapshots.
213 : */
214 : bool accessed_across_databases:1;
215 :
216 : /* Should stats be written to the on-disk stats file? */
217 : bool write_to_file:1;
218 :
219 : /*
220 : * The size of an entry in the shared stats hash table (pointed to by
221 : * PgStatShared_HashEntry->body). For fixed-numbered statistics, this is
222 : * the size of an entry in PgStat_ShmemControl->custom_data.
223 : */
224 : uint32 shared_size;
225 :
226 : /*
227 : * The offset of the statistics struct in the cached statistics snapshot
228 : * PgStat_Snapshot, for fixed-numbered statistics.
229 : */
230 : uint32 snapshot_ctl_off;
231 :
232 : /*
233 : * The offset of the statistics struct in the containing shared memory
234 : * control structure PgStat_ShmemControl, for fixed-numbered statistics.
235 : */
236 : uint32 shared_ctl_off;
237 :
238 : /*
239 : * The offset/size of statistics inside the shared stats entry. Used when
240 : * [de-]serializing statistics to / from disk respectively. Separate from
241 : * shared_size because [de-]serialization may not include in-memory state
242 : * like lwlocks.
243 : */
244 : uint32 shared_data_off;
245 : uint32 shared_data_len;
246 :
247 : /*
248 : * The size of the pending data for this kind. E.g. how large
249 : * PgStat_EntryRef->pending is. Used for allocations.
250 : *
251 : * 0 signals that an entry of this kind should never have a pending entry.
252 : */
253 : uint32 pending_size;
254 :
255 : /*
256 : * Perform custom actions when initializing a backend (standalone or under
257 : * postmaster). Optional.
258 : */
259 : void (*init_backend_cb) (void);
260 :
261 : /*
262 : * For variable-numbered stats: flush pending stats. Required if pending
263 : * data is used. See flush_static_cb when dealing with stats data that
264 : * that cannot use PgStat_EntryRef->pending.
265 : */
266 : bool (*flush_pending_cb) (PgStat_EntryRef *sr, bool nowait);
267 :
268 : /*
269 : * For variable-numbered stats: delete pending stats. Optional.
270 : */
271 : void (*delete_pending_cb) (PgStat_EntryRef *sr);
272 :
273 : /*
274 : * For variable-numbered stats: reset the reset timestamp. Optional.
275 : */
276 : void (*reset_timestamp_cb) (PgStatShared_Common *header, TimestampTz ts);
277 :
278 : /*
279 : * For variable-numbered stats. Optional.
280 : */
281 : void (*to_serialized_name) (const PgStat_HashKey *key,
282 : const PgStatShared_Common *header, NameData *name);
283 : bool (*from_serialized_name) (const NameData *name, PgStat_HashKey *key);
284 :
285 : /*
286 : * For fixed-numbered statistics: Initialize shared memory state.
287 : *
288 : * "stats" is the pointer to the allocated shared memory area.
289 : */
290 : void (*init_shmem_cb) (void *stats);
291 :
292 : /*
293 : * For fixed-numbered or variable-numbered statistics: Flush pending stats
294 : * entries, for stats kinds that do not use PgStat_EntryRef->pending.
295 : *
296 : * Returns true if some of the stats could not be flushed, due to lock
297 : * contention for example. Optional.
298 : */
299 : bool (*flush_static_cb) (bool nowait);
300 :
301 : /*
302 : * For fixed-numbered or variable-numbered statistics: Check for pending
303 : * stats in need of flush with flush_static_cb, when these do not use
304 : * PgStat_EntryRef->pending.
305 : *
306 : * Returns true if there are any stats pending for flush, triggering
307 : * flush_static_cb. Optional.
308 : */
309 : bool (*have_static_pending_cb) (void);
310 :
311 : /*
312 : * For fixed-numbered statistics: Reset All.
313 : */
314 : void (*reset_all_cb) (TimestampTz ts);
315 :
316 : /*
317 : * For fixed-numbered statistics: Build snapshot for entry
318 : */
319 : void (*snapshot_cb) (void);
320 :
321 : /* name of the kind of stats */
322 : const char *const name;
323 : } PgStat_KindInfo;
324 :
325 :
326 : /*
327 : * List of SLRU names that we keep stats for. There is no central registry of
328 : * SLRUs, so we use this fixed list instead. The "other" entry is used for
329 : * all SLRUs without an explicit entry (e.g. SLRUs in extensions).
330 : *
331 : * This is only defined here so that SLRU_NUM_ELEMENTS is known for later type
332 : * definitions.
333 : */
334 : static const char *const slru_names[] = {
335 : "commit_timestamp",
336 : "multixact_member",
337 : "multixact_offset",
338 : "notify",
339 : "serializable",
340 : "subtransaction",
341 : "transaction",
342 : "other" /* has to be last */
343 : };
344 :
345 : #define SLRU_NUM_ELEMENTS lengthof(slru_names)
346 :
347 :
348 : /* ----------
349 : * Types and definitions for different kinds of fixed-amount stats.
350 : *
351 : * Single-writer stats use the changecount mechanism to achieve low-overhead
352 : * writes - they're obviously more performance critical than reads. Check the
353 : * definition of struct PgBackendStatus for some explanation of the
354 : * changecount mechanism.
355 : *
356 : * Because the obvious implementation of resetting single-writer stats isn't
357 : * compatible with that (another backend needs to write), we don't scribble on
358 : * shared stats while resetting. Instead, just record the current counter
359 : * values in a copy of the stats data, which is protected by ->lock. See
360 : * pgstat_fetch_stat_(archiver|bgwriter|checkpointer) for the reader side.
361 : *
362 : * The only exception to that is the stat_reset_timestamp in these structs,
363 : * which is protected by ->lock, because it has to be written by another
364 : * backend while resetting.
365 : * ----------
366 : */
367 :
368 : typedef struct PgStatShared_Archiver
369 : {
370 : /* lock protects ->reset_offset as well as stats->stat_reset_timestamp */
371 : LWLock lock;
372 : uint32 changecount;
373 : PgStat_ArchiverStats stats;
374 : PgStat_ArchiverStats reset_offset;
375 : } PgStatShared_Archiver;
376 :
377 : typedef struct PgStatShared_BgWriter
378 : {
379 : /* lock protects ->reset_offset as well as stats->stat_reset_timestamp */
380 : LWLock lock;
381 : uint32 changecount;
382 : PgStat_BgWriterStats stats;
383 : PgStat_BgWriterStats reset_offset;
384 : } PgStatShared_BgWriter;
385 :
386 : typedef struct PgStatShared_Checkpointer
387 : {
388 : /* lock protects ->reset_offset as well as stats->stat_reset_timestamp */
389 : LWLock lock;
390 : uint32 changecount;
391 : PgStat_CheckpointerStats stats;
392 : PgStat_CheckpointerStats reset_offset;
393 : } PgStatShared_Checkpointer;
394 :
395 : /* Shared-memory ready PgStat_IO */
396 : typedef struct PgStatShared_IO
397 : {
398 : /*
399 : * locks[i] protects stats.stats[i]. locks[0] also protects
400 : * stats.stat_reset_timestamp.
401 : */
402 : LWLock locks[BACKEND_NUM_TYPES];
403 : PgStat_IO stats;
404 : } PgStatShared_IO;
405 :
406 : typedef struct PgStatShared_SLRU
407 : {
408 : /* lock protects ->stats */
409 : LWLock lock;
410 : PgStat_SLRUStats stats[SLRU_NUM_ELEMENTS];
411 : } PgStatShared_SLRU;
412 :
413 : typedef struct PgStatShared_Wal
414 : {
415 : /* lock protects ->stats */
416 : LWLock lock;
417 : PgStat_WalStats stats;
418 : } PgStatShared_Wal;
419 :
420 :
421 :
422 : /* ----------
423 : * Types and definitions for different kinds of variable-amount stats.
424 : *
425 : * Each struct has to start with PgStatShared_Common, containing information
426 : * common across the different types of stats. Kind-specific data follows.
427 : * ----------
428 : */
429 :
430 : typedef struct PgStatShared_Database
431 : {
432 : PgStatShared_Common header;
433 : PgStat_StatDBEntry stats;
434 : } PgStatShared_Database;
435 :
436 : typedef struct PgStatShared_Relation
437 : {
438 : PgStatShared_Common header;
439 : PgStat_StatTabEntry stats;
440 : } PgStatShared_Relation;
441 :
442 : typedef struct PgStatShared_Function
443 : {
444 : PgStatShared_Common header;
445 : PgStat_StatFuncEntry stats;
446 : } PgStatShared_Function;
447 :
448 : typedef struct PgStatShared_Subscription
449 : {
450 : PgStatShared_Common header;
451 : PgStat_StatSubEntry stats;
452 : } PgStatShared_Subscription;
453 :
454 : typedef struct PgStatShared_ReplSlot
455 : {
456 : PgStatShared_Common header;
457 : PgStat_StatReplSlotEntry stats;
458 : } PgStatShared_ReplSlot;
459 :
460 : typedef struct PgStatShared_Backend
461 : {
462 : PgStatShared_Common header;
463 : PgStat_Backend stats;
464 : } PgStatShared_Backend;
465 :
466 : /*
467 : * Central shared memory entry for the cumulative stats system.
468 : *
469 : * Fixed amount stats, the dynamic shared memory hash table for
470 : * non-fixed-amount stats, as well as remaining bits and pieces are all
471 : * reached from here.
472 : */
473 : typedef struct PgStat_ShmemControl
474 : {
475 : void *raw_dsa_area;
476 :
477 : /*
478 : * Stats for variable-numbered objects are kept in this shared hash table.
479 : * See comment above PgStat_Kind for details.
480 : */
481 : dshash_table_handle hash_handle; /* shared dbstat hash */
482 :
483 : /* Has the stats system already been shut down? Just a debugging check. */
484 : bool is_shutdown;
485 :
486 : /*
487 : * Whenever statistics for dropped objects could not be freed - because
488 : * backends still have references - the dropping backend calls
489 : * pgstat_request_entry_refs_gc() incrementing this counter. Eventually
490 : * that causes backends to run pgstat_gc_entry_refs(), allowing memory to
491 : * be reclaimed.
492 : */
493 : pg_atomic_uint64 gc_request_count;
494 :
495 : /*
496 : * Stats data for fixed-numbered objects.
497 : */
498 : PgStatShared_Archiver archiver;
499 : PgStatShared_BgWriter bgwriter;
500 : PgStatShared_Checkpointer checkpointer;
501 : PgStatShared_IO io;
502 : PgStatShared_SLRU slru;
503 : PgStatShared_Wal wal;
504 :
505 : /*
506 : * Custom stats data with fixed-numbered objects, indexed by (PgStat_Kind
507 : * - PGSTAT_KIND_CUSTOM_MIN).
508 : */
509 : void *custom_data[PGSTAT_KIND_CUSTOM_SIZE];
510 :
511 : } PgStat_ShmemControl;
512 :
513 :
514 : /*
515 : * Cached statistics snapshot
516 : */
517 : typedef struct PgStat_Snapshot
518 : {
519 : PgStat_FetchConsistency mode;
520 :
521 : /* time at which snapshot was taken */
522 : TimestampTz snapshot_timestamp;
523 :
524 : bool fixed_valid[PGSTAT_KIND_BUILTIN_SIZE];
525 :
526 : PgStat_ArchiverStats archiver;
527 :
528 : PgStat_BgWriterStats bgwriter;
529 :
530 : PgStat_CheckpointerStats checkpointer;
531 :
532 : PgStat_IO io;
533 :
534 : PgStat_SLRUStats slru[SLRU_NUM_ELEMENTS];
535 :
536 : PgStat_WalStats wal;
537 :
538 : /*
539 : * Data in snapshot for custom fixed-numbered statistics, indexed by
540 : * (PgStat_Kind - PGSTAT_KIND_CUSTOM_MIN). Each entry is allocated in
541 : * TopMemoryContext, for a size of PgStat_KindInfo->shared_data_len.
542 : */
543 : bool custom_valid[PGSTAT_KIND_CUSTOM_SIZE];
544 : void *custom_data[PGSTAT_KIND_CUSTOM_SIZE];
545 :
546 : /* to free snapshot in bulk */
547 : MemoryContext context;
548 : struct pgstat_snapshot_hash *stats;
549 : } PgStat_Snapshot;
550 :
551 :
552 : /*
553 : * Collection of backend-local stats state.
554 : */
555 : typedef struct PgStat_LocalState
556 : {
557 : PgStat_ShmemControl *shmem;
558 : dsa_area *dsa;
559 : dshash_table *shared_hash;
560 :
561 : /* the current statistics snapshot */
562 : PgStat_Snapshot snapshot;
563 : } PgStat_LocalState;
564 :
565 :
566 : /*
567 : * Inline functions defined further below.
568 : */
569 :
570 : static inline void pgstat_begin_changecount_write(uint32 *cc);
571 : static inline void pgstat_end_changecount_write(uint32 *cc);
572 : static inline uint32 pgstat_begin_changecount_read(uint32 *cc);
573 : static inline bool pgstat_end_changecount_read(uint32 *cc, uint32 cc_before);
574 :
575 : static inline void pgstat_copy_changecounted_stats(void *dst, void *src, size_t len,
576 : uint32 *cc);
577 :
578 : static inline int pgstat_cmp_hash_key(const void *a, const void *b, size_t size, void *arg);
579 : static inline uint32 pgstat_hash_hash_key(const void *d, size_t size, void *arg);
580 : static inline size_t pgstat_get_entry_len(PgStat_Kind kind);
581 : static inline void *pgstat_get_entry_data(PgStat_Kind kind, PgStatShared_Common *entry);
582 : static inline void *pgstat_get_custom_shmem_data(PgStat_Kind kind);
583 : static inline void *pgstat_get_custom_snapshot_data(PgStat_Kind kind);
584 :
585 :
586 : /*
587 : * Functions in pgstat.c
588 : */
589 :
590 : extern const PgStat_KindInfo *pgstat_get_kind_info(PgStat_Kind kind);
591 : extern void pgstat_register_kind(PgStat_Kind kind,
592 : const PgStat_KindInfo *kind_info);
593 :
594 : #ifdef USE_ASSERT_CHECKING
595 : extern void pgstat_assert_is_up(void);
596 : #else
597 : #define pgstat_assert_is_up() ((void)true)
598 : #endif
599 :
600 : extern void pgstat_delete_pending_entry(PgStat_EntryRef *entry_ref);
601 : extern PgStat_EntryRef *pgstat_prep_pending_entry(PgStat_Kind kind, Oid dboid,
602 : uint64 objid,
603 : bool *created_entry);
604 : extern PgStat_EntryRef *pgstat_fetch_pending_entry(PgStat_Kind kind,
605 : Oid dboid, uint64 objid);
606 :
607 : extern void *pgstat_fetch_entry(PgStat_Kind kind, Oid dboid, uint64 objid);
608 : extern void pgstat_snapshot_fixed(PgStat_Kind kind);
609 :
610 :
611 : /*
612 : * Functions in pgstat_archiver.c
613 : */
614 :
615 : extern void pgstat_archiver_init_shmem_cb(void *stats);
616 : extern void pgstat_archiver_reset_all_cb(TimestampTz ts);
617 : extern void pgstat_archiver_snapshot_cb(void);
618 :
619 : /*
620 : * Functions in pgstat_backend.c
621 : */
622 :
623 : /* flags for pgstat_flush_backend() */
624 : #define PGSTAT_BACKEND_FLUSH_IO (1 << 0) /* Flush I/O statistics */
625 : #define PGSTAT_BACKEND_FLUSH_ALL (PGSTAT_BACKEND_FLUSH_IO)
626 :
627 : extern bool pgstat_flush_backend(bool nowait, bits32 flags);
628 : extern bool pgstat_backend_flush_cb(bool nowait);
629 : extern bool pgstat_backend_have_pending_cb(void);
630 : extern void pgstat_backend_reset_timestamp_cb(PgStatShared_Common *header,
631 : TimestampTz ts);
632 :
633 : /*
634 : * Functions in pgstat_bgwriter.c
635 : */
636 :
637 : extern void pgstat_bgwriter_init_shmem_cb(void *stats);
638 : extern void pgstat_bgwriter_reset_all_cb(TimestampTz ts);
639 : extern void pgstat_bgwriter_snapshot_cb(void);
640 :
641 :
642 : /*
643 : * Functions in pgstat_checkpointer.c
644 : */
645 :
646 : extern void pgstat_checkpointer_init_shmem_cb(void *stats);
647 : extern void pgstat_checkpointer_reset_all_cb(TimestampTz ts);
648 : extern void pgstat_checkpointer_snapshot_cb(void);
649 :
650 :
651 : /*
652 : * Functions in pgstat_database.c
653 : */
654 :
655 : extern void pgstat_report_disconnect(Oid dboid);
656 : extern void pgstat_update_dbstats(TimestampTz ts);
657 : extern void AtEOXact_PgStat_Database(bool isCommit, bool parallel);
658 :
659 : extern PgStat_StatDBEntry *pgstat_prep_database_pending(Oid dboid);
660 : extern void pgstat_reset_database_timestamp(Oid dboid, TimestampTz ts);
661 : extern bool pgstat_database_flush_cb(PgStat_EntryRef *entry_ref, bool nowait);
662 : extern void pgstat_database_reset_timestamp_cb(PgStatShared_Common *header, TimestampTz ts);
663 :
664 :
665 : /*
666 : * Functions in pgstat_function.c
667 : */
668 :
669 : extern bool pgstat_function_flush_cb(PgStat_EntryRef *entry_ref, bool nowait);
670 :
671 :
672 : /*
673 : * Functions in pgstat_io.c
674 : */
675 :
676 : extern void pgstat_flush_io(bool nowait);
677 :
678 : extern bool pgstat_io_have_pending_cb(void);
679 : extern bool pgstat_io_flush_cb(bool nowait);
680 : extern void pgstat_io_init_shmem_cb(void *stats);
681 : extern void pgstat_io_reset_all_cb(TimestampTz ts);
682 : extern void pgstat_io_snapshot_cb(void);
683 :
684 :
685 : /*
686 : * Functions in pgstat_relation.c
687 : */
688 :
689 : extern void AtEOXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit);
690 : extern void AtEOSubXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit, int nestDepth);
691 : extern void AtPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state);
692 : extern void PostPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state);
693 :
694 : extern bool pgstat_relation_flush_cb(PgStat_EntryRef *entry_ref, bool nowait);
695 : extern void pgstat_relation_delete_pending_cb(PgStat_EntryRef *entry_ref);
696 :
697 :
698 : /*
699 : * Functions in pgstat_replslot.c
700 : */
701 :
702 : extern void pgstat_replslot_reset_timestamp_cb(PgStatShared_Common *header, TimestampTz ts);
703 : extern void pgstat_replslot_to_serialized_name_cb(const PgStat_HashKey *key, const PgStatShared_Common *header, NameData *name);
704 : extern bool pgstat_replslot_from_serialized_name_cb(const NameData *name, PgStat_HashKey *key);
705 :
706 :
707 : /*
708 : * Functions in pgstat_shmem.c
709 : */
710 :
711 : extern void pgstat_attach_shmem(void);
712 : extern void pgstat_detach_shmem(void);
713 :
714 : extern PgStat_EntryRef *pgstat_get_entry_ref(PgStat_Kind kind, Oid dboid, uint64 objid,
715 : bool create, bool *created_entry);
716 : extern bool pgstat_lock_entry(PgStat_EntryRef *entry_ref, bool nowait);
717 : extern bool pgstat_lock_entry_shared(PgStat_EntryRef *entry_ref, bool nowait);
718 : extern void pgstat_unlock_entry(PgStat_EntryRef *entry_ref);
719 : extern bool pgstat_drop_entry(PgStat_Kind kind, Oid dboid, uint64 objid);
720 : extern void pgstat_drop_all_entries(void);
721 : extern void pgstat_drop_matching_entries(bool (*do_drop) (PgStatShared_HashEntry *, Datum),
722 : Datum match_data);
723 : extern PgStat_EntryRef *pgstat_get_entry_ref_locked(PgStat_Kind kind, Oid dboid, uint64 objid,
724 : bool nowait);
725 : extern void pgstat_reset_entry(PgStat_Kind kind, Oid dboid, uint64 objid, TimestampTz ts);
726 : extern void pgstat_reset_entries_of_kind(PgStat_Kind kind, TimestampTz ts);
727 : extern void pgstat_reset_matching_entries(bool (*do_reset) (PgStatShared_HashEntry *, Datum),
728 : Datum match_data,
729 : TimestampTz ts);
730 :
731 : extern void pgstat_request_entry_refs_gc(void);
732 : extern PgStatShared_Common *pgstat_init_entry(PgStat_Kind kind,
733 : PgStatShared_HashEntry *shhashent);
734 :
735 :
736 : /*
737 : * Functions in pgstat_slru.c
738 : */
739 :
740 : extern bool pgstat_slru_have_pending_cb(void);
741 : extern bool pgstat_slru_flush_cb(bool nowait);
742 : extern void pgstat_slru_init_shmem_cb(void *stats);
743 : extern void pgstat_slru_reset_all_cb(TimestampTz ts);
744 : extern void pgstat_slru_snapshot_cb(void);
745 :
746 :
747 : /*
748 : * Functions in pgstat_wal.c
749 : */
750 :
751 : extern void pgstat_flush_wal(bool nowait);
752 :
753 : extern void pgstat_wal_init_backend_cb(void);
754 : extern bool pgstat_wal_have_pending_cb(void);
755 : extern bool pgstat_wal_flush_cb(bool nowait);
756 : extern void pgstat_wal_init_shmem_cb(void *stats);
757 : extern void pgstat_wal_reset_all_cb(TimestampTz ts);
758 : extern void pgstat_wal_snapshot_cb(void);
759 :
760 :
761 : /*
762 : * Functions in pgstat_subscription.c
763 : */
764 :
765 : extern bool pgstat_subscription_flush_cb(PgStat_EntryRef *entry_ref, bool nowait);
766 : extern void pgstat_subscription_reset_timestamp_cb(PgStatShared_Common *header, TimestampTz ts);
767 :
768 :
769 : /*
770 : * Functions in pgstat_xact.c
771 : */
772 :
773 : extern PgStat_SubXactStatus *pgstat_get_xact_stack_level(int nest_level);
774 : extern void pgstat_drop_transactional(PgStat_Kind kind, Oid dboid, uint64 objid);
775 : extern void pgstat_create_transactional(PgStat_Kind kind, Oid dboid, uint64 objid);
776 :
777 :
778 : /*
779 : * Variables in pgstat.c
780 : */
781 :
782 : extern PGDLLIMPORT PgStat_LocalState pgStatLocal;
783 :
784 :
785 : /*
786 : * Implementation of inline functions declared above.
787 : */
788 :
789 : /*
790 : * Helpers for changecount manipulation. See comments around struct
791 : * PgBackendStatus for details.
792 : */
793 :
794 : static inline void
795 19310 : pgstat_begin_changecount_write(uint32 *cc)
796 : {
797 : Assert((*cc & 1) == 0);
798 :
799 19310 : START_CRIT_SECTION();
800 19310 : (*cc)++;
801 19310 : pg_write_barrier();
802 19310 : }
803 :
804 : static inline void
805 19310 : pgstat_end_changecount_write(uint32 *cc)
806 : {
807 : Assert((*cc & 1) == 1);
808 :
809 19310 : pg_write_barrier();
810 :
811 19310 : (*cc)++;
812 :
813 19310 : END_CRIT_SECTION();
814 19310 : }
815 :
816 : static inline uint32
817 4992 : pgstat_begin_changecount_read(uint32 *cc)
818 : {
819 4992 : uint32 before_cc = *cc;
820 :
821 4992 : CHECK_FOR_INTERRUPTS();
822 :
823 4992 : pg_read_barrier();
824 :
825 4992 : return before_cc;
826 : }
827 :
828 : /*
829 : * Returns true if the read succeeded, false if it needs to be repeated.
830 : */
831 : static inline bool
832 4992 : pgstat_end_changecount_read(uint32 *cc, uint32 before_cc)
833 : {
834 : uint32 after_cc;
835 :
836 4992 : pg_read_barrier();
837 :
838 4992 : after_cc = *cc;
839 :
840 : /* was a write in progress when we started? */
841 4992 : if (before_cc & 1)
842 0 : return false;
843 :
844 : /* did writes start and complete while we read? */
845 4992 : return before_cc == after_cc;
846 : }
847 :
848 :
849 : /*
850 : * helper function for PgStat_KindInfo->snapshot_cb
851 : * PgStat_KindInfo->reset_all_cb callbacks.
852 : *
853 : * Copies out the specified memory area following change-count protocol.
854 : */
855 : static inline void
856 4992 : pgstat_copy_changecounted_stats(void *dst, void *src, size_t len,
857 : uint32 *cc)
858 : {
859 : uint32 cc_before;
860 :
861 : do
862 : {
863 4992 : cc_before = pgstat_begin_changecount_read(cc);
864 :
865 4992 : memcpy(dst, src, len);
866 : }
867 4992 : while (!pgstat_end_changecount_read(cc, cc_before));
868 4992 : }
869 :
870 : /* helpers for dshash / simplehash hashtables */
871 : static inline int
872 8395066 : pgstat_cmp_hash_key(const void *a, const void *b, size_t size, void *arg)
873 : {
874 : Assert(size == sizeof(PgStat_HashKey) && arg == NULL);
875 8395066 : return memcmp(a, b, sizeof(PgStat_HashKey));
876 : }
877 :
878 : static inline uint32
879 10706616 : pgstat_hash_hash_key(const void *d, size_t size, void *arg)
880 : {
881 10706616 : const char *key = (const char *) d;
882 :
883 : Assert(size == sizeof(PgStat_HashKey) && arg == NULL);
884 10706616 : return fasthash32(key, size, 0);
885 : }
886 :
887 : /*
888 : * The length of the data portion of a shared memory stats entry (i.e. without
889 : * transient data such as refcounts, lwlocks, ...).
890 : */
891 : static inline size_t
892 666880 : pgstat_get_entry_len(PgStat_Kind kind)
893 : {
894 666880 : return pgstat_get_kind_info(kind)->shared_data_len;
895 : }
896 :
897 : /*
898 : * Returns a pointer to the data portion of a shared memory stats entry.
899 : */
900 : static inline void *
901 1069942 : pgstat_get_entry_data(PgStat_Kind kind, PgStatShared_Common *entry)
902 : {
903 1069942 : size_t off = pgstat_get_kind_info(kind)->shared_data_off;
904 :
905 : Assert(off != 0 && off < PG_UINT32_MAX);
906 :
907 1069942 : return ((char *) (entry)) + off;
908 : }
909 :
910 : /*
911 : * Returns a pointer to the shared memory area of custom stats for
912 : * fixed-numbered statistics.
913 : */
914 : static inline void *
915 30 : pgstat_get_custom_shmem_data(PgStat_Kind kind)
916 : {
917 30 : int idx = kind - PGSTAT_KIND_CUSTOM_MIN;
918 :
919 : Assert(pgstat_is_kind_custom(kind));
920 : Assert(pgstat_get_kind_info(kind)->fixed_amount);
921 :
922 30 : return pgStatLocal.shmem->custom_data[idx];
923 : }
924 :
925 : /*
926 : * Returns a pointer to the portion of custom data for fixed-numbered
927 : * statistics in the current snapshot.
928 : */
929 : static inline void *
930 18 : pgstat_get_custom_snapshot_data(PgStat_Kind kind)
931 : {
932 18 : int idx = kind - PGSTAT_KIND_CUSTOM_MIN;
933 :
934 : Assert(pgstat_is_kind_custom(kind));
935 : Assert(pgstat_get_kind_info(kind)->fixed_amount);
936 :
937 18 : return pgStatLocal.snapshot.custom_data[idx];
938 : }
939 :
940 : #endif /* PGSTAT_INTERNAL_H */
|