PostgreSQL Source Code  git master
pgstat_shmem.c
Go to the documentation of this file.
1 /* -------------------------------------------------------------------------
2  *
3  * pgstat_shmem.c
4  * Storage of stats entries in shared memory
5  *
6  * Copyright (c) 2001-2024, PostgreSQL Global Development Group
7  *
8  * IDENTIFICATION
9  * src/backend/utils/activity/pgstat_shmem.c
10  * -------------------------------------------------------------------------
11  */
12 
13 #include "postgres.h"
14 
15 #include "pgstat.h"
16 #include "storage/shmem.h"
17 #include "utils/memutils.h"
18 #include "utils/pgstat_internal.h"
19 
20 
21 #define PGSTAT_ENTRY_REF_HASH_SIZE 128
22 
23 /* hash table entry for finding the PgStat_EntryRef for a key */
25 {
26  PgStat_HashKey key; /* hash key */
27  char status; /* for simplehash use */
30 
31 
32 /* for references to shared statistics entries */
33 #define SH_PREFIX pgstat_entry_ref_hash
34 #define SH_ELEMENT_TYPE PgStat_EntryRefHashEntry
35 #define SH_KEY_TYPE PgStat_HashKey
36 #define SH_KEY key
37 #define SH_HASH_KEY(tb, key) \
38  pgstat_hash_hash_key(&key, sizeof(PgStat_HashKey), NULL)
39 #define SH_EQUAL(tb, a, b) \
40  pgstat_cmp_hash_key(&a, &b, sizeof(PgStat_HashKey), NULL) == 0
41 #define SH_SCOPE static inline
42 #define SH_DEFINE
43 #define SH_DECLARE
44 #include "lib/simplehash.h"
45 
46 
47 static void pgstat_drop_database_and_contents(Oid dboid);
48 
50 
51 static void pgstat_release_entry_ref(PgStat_HashKey key, PgStat_EntryRef *entry_ref, bool discard_pending);
52 static bool pgstat_need_entry_refs_gc(void);
53 static void pgstat_gc_entry_refs(void);
54 static void pgstat_release_all_entry_refs(bool discard_pending);
56 static void pgstat_release_matching_entry_refs(bool discard_pending, ReleaseMatchCB match, Datum match_data);
57 
58 static void pgstat_setup_memcxt(void);
59 
60 
61 /* parameter for the shared hash */
62 static const dshash_parameters dsh_params = {
63  sizeof(PgStat_HashKey),
64  sizeof(PgStatShared_HashEntry),
69 };
70 
71 
72 /*
73  * Backend local references to shared stats entries. If there are pending
74  * updates to a stats entry, the PgStat_EntryRef is added to the pgStatPending
75  * list.
76  *
77  * When a stats entry is dropped each backend needs to release its reference
78  * to it before the memory can be released. To trigger that
79  * pgStatLocal.shmem->gc_request_count is incremented - which each backend
80  * compares to their copy of pgStatSharedRefAge on a regular basis.
81  */
82 static pgstat_entry_ref_hash_hash *pgStatEntryRefHash = NULL;
83 static int pgStatSharedRefAge = 0; /* cache age of pgStatShmLookupCache */
84 
85 /*
86  * Memory contexts containing the pgStatEntryRefHash table and the
87  * pgStatSharedRef entries respectively. Kept separate to make it easier to
88  * track / attribute memory usage.
89  */
92 
93 
94 /* ------------------------------------------------------------
95  * Public functions called from postmaster follow
96  * ------------------------------------------------------------
97  */
98 
99 /*
100  * The size of the shared memory allocation for stats stored in the shared
101  * stats hash table. This allocation will be done as part of the main shared
102  * memory, rather than dynamic shared memory, allowing it to be initialized in
103  * postmaster.
104  */
105 static Size
107 {
108  Size sz;
109 
110  /*
111  * The dshash header / initial buckets array needs to fit into "plain"
112  * shared memory, but it's beneficial to not need dsm segments
113  * immediately. A size of 256kB seems works well and is not
114  * disproportional compared to other constant sized shared memory
115  * allocations. NB: To avoid DSMs further, the user can configure
116  * min_dynamic_shared_memory.
117  */
118  sz = 256 * 1024;
119  Assert(dsa_minimum_size() <= sz);
120  return MAXALIGN(sz);
121 }
122 
123 /*
124  * Compute shared memory space needed for cumulative statistics
125  */
126 Size
128 {
129  Size sz;
130 
131  sz = MAXALIGN(sizeof(PgStat_ShmemControl));
132  sz = add_size(sz, pgstat_dsa_init_size());
133 
134  return sz;
135 }
136 
137 /*
138  * Initialize cumulative statistics system during startup
139  */
140 void
142 {
143  bool found;
144  Size sz;
145 
146  sz = StatsShmemSize();
148  ShmemInitStruct("Shared Memory Stats", sz, &found);
149 
150  if (!IsUnderPostmaster)
151  {
152  dsa_area *dsa;
153  dshash_table *dsh;
155  char *p = (char *) ctl;
156 
157  Assert(!found);
158 
159  /* the allocation of pgStatLocal.shmem itself */
160  p += MAXALIGN(sizeof(PgStat_ShmemControl));
161 
162  /*
163  * Create a small dsa allocation in plain shared memory. This is
164  * required because postmaster cannot use dsm segments. It also
165  * provides a small efficiency win.
166  */
167  ctl->raw_dsa_area = p;
169  dsa = dsa_create_in_place(ctl->raw_dsa_area,
172  dsa_pin(dsa);
173 
174  /*
175  * To ensure dshash is created in "plain" shared memory, temporarily
176  * limit size of dsa to the initial size of the dsa.
177  */
179 
180  /*
181  * With the limit in place, create the dshash table. XXX: It'd be nice
182  * if there were dshash_create_in_place().
183  */
184  dsh = dshash_create(dsa, &dsh_params, NULL);
185  ctl->hash_handle = dshash_get_hash_table_handle(dsh);
186 
187  /* lift limit set above */
188  dsa_set_size_limit(dsa, -1);
189 
190  /*
191  * Postmaster will never access these again, thus free the local
192  * dsa/dshash references.
193  */
194  dshash_detach(dsh);
195  dsa_detach(dsa);
196 
197  pg_atomic_init_u64(&ctl->gc_request_count, 1);
198 
199 
200  /* initialize fixed-numbered stats */
201  LWLockInitialize(&ctl->archiver.lock, LWTRANCHE_PGSTATS_DATA);
202  LWLockInitialize(&ctl->bgwriter.lock, LWTRANCHE_PGSTATS_DATA);
203  LWLockInitialize(&ctl->checkpointer.lock, LWTRANCHE_PGSTATS_DATA);
206 
207  for (int i = 0; i < BACKEND_NUM_TYPES; i++)
208  LWLockInitialize(&ctl->io.locks[i],
210  }
211  else
212  {
213  Assert(found);
214  }
215 }
216 
217 void
219 {
220  MemoryContext oldcontext;
221 
222  Assert(pgStatLocal.dsa == NULL);
223 
224  /* stats shared memory persists for the backend lifetime */
226 
228  NULL);
230 
233 
234  MemoryContextSwitchTo(oldcontext);
235 }
236 
237 void
239 {
241 
242  /* we shouldn't leave references to shared stats */
244 
246  pgStatLocal.shared_hash = NULL;
247 
249  pgStatLocal.dsa = NULL;
250 }
251 
252 
253 /* ------------------------------------------------------------
254  * Maintenance of shared memory stats entries
255  * ------------------------------------------------------------
256  */
257 
260  PgStatShared_HashEntry *shhashent)
261 {
262  /* Create new stats entry. */
264  PgStatShared_Common *shheader;
265 
266  /*
267  * Initialize refcount to 1, marking it as valid / not dropped. The entry
268  * can't be freed before the initialization because it can't be found as
269  * long as we hold the dshash partition lock. Caller needs to increase
270  * further if a longer lived reference is needed.
271  */
272  pg_atomic_init_u32(&shhashent->refcount, 1);
273  shhashent->dropped = false;
274 
275  chunk = dsa_allocate0(pgStatLocal.dsa, pgstat_get_kind_info(kind)->shared_size);
276  shheader = dsa_get_address(pgStatLocal.dsa, chunk);
277  shheader->magic = 0xdeadbeef;
278 
279  /* Link the new entry from the hash entry. */
280  shhashent->body = chunk;
281 
283 
284  return shheader;
285 }
286 
287 static PgStatShared_Common *
289 {
290  PgStatShared_Common *shheader;
291 
292  shheader = dsa_get_address(pgStatLocal.dsa, shhashent->body);
293 
294  /* mark as not dropped anymore */
295  pg_atomic_fetch_add_u32(&shhashent->refcount, 1);
296  shhashent->dropped = false;
297 
298  /* reinitialize content */
299  Assert(shheader->magic == 0xdeadbeef);
300  memset(pgstat_get_entry_data(kind, shheader), 0,
301  pgstat_get_entry_len(kind));
302 
303  return shheader;
304 }
305 
306 static void
308 {
309  if (likely(pgStatEntryRefHash != NULL))
310  return;
311 
313  pgstat_entry_ref_hash_create(pgStatEntryRefHashContext,
317 }
318 
319 /*
320  * Helper function for pgstat_get_entry_ref().
321  */
322 static void
324  PgStatShared_HashEntry *shhashent,
325  PgStatShared_Common *shheader)
326 {
327  Assert(shheader->magic == 0xdeadbeef);
328  Assert(pg_atomic_read_u32(&shhashent->refcount) > 0);
329 
330  pg_atomic_fetch_add_u32(&shhashent->refcount, 1);
331 
333 
334  entry_ref->shared_stats = shheader;
335  entry_ref->shared_entry = shhashent;
336 }
337 
338 /*
339  * Helper function for pgstat_get_entry_ref().
340  */
341 static bool
343 {
344  bool found;
345  PgStat_EntryRefHashEntry *cache_entry;
346 
347  /*
348  * We immediately insert a cache entry, because it avoids 1) multiple
349  * hashtable lookups in case of a cache miss 2) having to deal with
350  * out-of-memory errors after incrementing PgStatShared_Common->refcount.
351  */
352 
353  cache_entry = pgstat_entry_ref_hash_insert(pgStatEntryRefHash, key, &found);
354 
355  if (!found || !cache_entry->entry_ref)
356  {
357  PgStat_EntryRef *entry_ref;
358 
359  cache_entry->entry_ref = entry_ref =
361  sizeof(PgStat_EntryRef));
362  entry_ref->shared_stats = NULL;
363  entry_ref->shared_entry = NULL;
364  entry_ref->pending = NULL;
365 
366  found = false;
367  }
368  else if (cache_entry->entry_ref->shared_stats == NULL)
369  {
370  Assert(cache_entry->entry_ref->pending == NULL);
371  found = false;
372  }
373  else
374  {
376 
377  entry_ref = cache_entry->entry_ref;
378  Assert(entry_ref->shared_entry != NULL);
379  Assert(entry_ref->shared_stats != NULL);
380 
381  Assert(entry_ref->shared_stats->magic == 0xdeadbeef);
382  /* should have at least our reference */
383  Assert(pg_atomic_read_u32(&entry_ref->shared_entry->refcount) > 0);
384  }
385 
386  *entry_ref_p = cache_entry->entry_ref;
387  return found;
388 }
389 
390 /*
391  * Get a shared stats reference. If create is true, the shared stats object is
392  * created if it does not exist.
393  *
394  * When create is true, and created_entry is non-NULL, it'll be set to true
395  * if the entry is newly created, false otherwise.
396  */
398 pgstat_get_entry_ref(PgStat_Kind kind, Oid dboid, Oid objoid, bool create,
399  bool *created_entry)
400 {
401  PgStat_HashKey key = {.kind = kind,.dboid = dboid,.objoid = objoid};
402  PgStatShared_HashEntry *shhashent;
403  PgStatShared_Common *shheader = NULL;
404  PgStat_EntryRef *entry_ref;
405 
406  /*
407  * passing in created_entry only makes sense if we possibly could create
408  * entry.
409  */
410  Assert(create || created_entry == NULL);
412  Assert(pgStatLocal.shared_hash != NULL);
414 
417 
418  if (created_entry != NULL)
419  *created_entry = false;
420 
421  /*
422  * Check if other backends dropped stats that could not be deleted because
423  * somebody held references to it. If so, check this backend's references.
424  * This is not expected to happen often. The location of the check is a
425  * bit random, but this is a relatively frequently called path, so better
426  * than most.
427  */
430 
431  /*
432  * First check the lookup cache hashtable in local memory. If we find a
433  * match here we can avoid taking locks / causing contention.
434  */
435  if (pgstat_get_entry_ref_cached(key, &entry_ref))
436  return entry_ref;
437 
438  Assert(entry_ref != NULL);
439 
440  /*
441  * Do a lookup in the hash table first - it's quite likely that the entry
442  * already exists, and that way we only need a shared lock.
443  */
444  shhashent = dshash_find(pgStatLocal.shared_hash, &key, false);
445 
446  if (create && !shhashent)
447  {
448  bool shfound;
449 
450  /*
451  * It's possible that somebody created the entry since the above
452  * lookup. If so, fall through to the same path as if we'd have if it
453  * already had been created before the dshash_find() calls.
454  */
455  shhashent = dshash_find_or_insert(pgStatLocal.shared_hash, &key, &shfound);
456  if (!shfound)
457  {
458  shheader = pgstat_init_entry(kind, shhashent);
459  pgstat_acquire_entry_ref(entry_ref, shhashent, shheader);
460 
461  if (created_entry != NULL)
462  *created_entry = true;
463 
464  return entry_ref;
465  }
466  }
467 
468  if (!shhashent)
469  {
470  /*
471  * If we're not creating, delete the reference again. In all
472  * likelihood it's just a stats lookup - no point wasting memory for a
473  * shared ref to nothing...
474  */
475  pgstat_release_entry_ref(key, entry_ref, false);
476 
477  return NULL;
478  }
479  else
480  {
481  /*
482  * Can get here either because dshash_find() found a match, or if
483  * dshash_find_or_insert() found a concurrently inserted entry.
484  */
485 
486  if (shhashent->dropped && create)
487  {
488  /*
489  * There are legitimate cases where the old stats entry might not
490  * yet have been dropped by the time it's reused. The most obvious
491  * case are replication slot stats, where a new slot can be
492  * created with the same index just after dropping. But oid
493  * wraparound can lead to other cases as well. We just reset the
494  * stats to their plain state.
495  */
496  shheader = pgstat_reinit_entry(kind, shhashent);
497  pgstat_acquire_entry_ref(entry_ref, shhashent, shheader);
498 
499  if (created_entry != NULL)
500  *created_entry = true;
501 
502  return entry_ref;
503  }
504  else if (shhashent->dropped)
505  {
507  pgstat_release_entry_ref(key, entry_ref, false);
508 
509  return NULL;
510  }
511  else
512  {
513  shheader = dsa_get_address(pgStatLocal.dsa, shhashent->body);
514  pgstat_acquire_entry_ref(entry_ref, shhashent, shheader);
515 
516  return entry_ref;
517  }
518  }
519 }
520 
521 static void
523  bool discard_pending)
524 {
525  if (entry_ref && entry_ref->pending)
526  {
527  if (discard_pending)
528  pgstat_delete_pending_entry(entry_ref);
529  else
530  elog(ERROR, "releasing ref with pending data");
531  }
532 
533  if (entry_ref && entry_ref->shared_stats)
534  {
535  Assert(entry_ref->shared_stats->magic == 0xdeadbeef);
536  Assert(entry_ref->pending == NULL);
537 
538  /*
539  * This can't race with another backend looking up the stats entry and
540  * increasing the refcount because it is not "legal" to create
541  * additional references to dropped entries.
542  */
543  if (pg_atomic_fetch_sub_u32(&entry_ref->shared_entry->refcount, 1) == 1)
544  {
545  PgStatShared_HashEntry *shent;
546 
547  /*
548  * We're the last referrer to this entry, try to drop the shared
549  * entry.
550  */
551 
552  /* only dropped entries can reach a 0 refcount */
553  Assert(entry_ref->shared_entry->dropped);
554 
556  &entry_ref->shared_entry->key,
557  true);
558  if (!shent)
559  elog(ERROR, "could not find just referenced shared stats entry");
560 
561  Assert(pg_atomic_read_u32(&entry_ref->shared_entry->refcount) == 0);
562  Assert(entry_ref->shared_entry == shent);
563 
564  pgstat_free_entry(shent, NULL);
565  }
566  }
567 
568  if (!pgstat_entry_ref_hash_delete(pgStatEntryRefHash, key))
569  elog(ERROR, "entry ref vanished before deletion");
570 
571  if (entry_ref)
572  pfree(entry_ref);
573 }
574 
575 bool
576 pgstat_lock_entry(PgStat_EntryRef *entry_ref, bool nowait)
577 {
578  LWLock *lock = &entry_ref->shared_stats->lock;
579 
580  if (nowait)
582 
584  return true;
585 }
586 
587 /*
588  * Separate from pgstat_lock_entry() as most callers will need to lock
589  * exclusively.
590  */
591 bool
593 {
594  LWLock *lock = &entry_ref->shared_stats->lock;
595 
596  if (nowait)
597  return LWLockConditionalAcquire(lock, LW_SHARED);
598 
599  LWLockAcquire(lock, LW_SHARED);
600  return true;
601 }
602 
603 void
605 {
606  LWLockRelease(&entry_ref->shared_stats->lock);
607 }
608 
609 /*
610  * Helper function to fetch and lock shared stats.
611  */
614  bool nowait)
615 {
616  PgStat_EntryRef *entry_ref;
617 
618  /* find shared table stats entry corresponding to the local entry */
619  entry_ref = pgstat_get_entry_ref(kind, dboid, objoid, true, NULL);
620 
621  /* lock the shared entry to protect the content, skip if failed */
622  if (!pgstat_lock_entry(entry_ref, nowait))
623  return NULL;
624 
625  return entry_ref;
626 }
627 
628 void
630 {
632 }
633 
634 static bool
636 {
637  uint64 curage;
638 
639  if (!pgStatEntryRefHash)
640  return false;
641 
642  /* should have been initialized when creating pgStatEntryRefHash */
644 
646 
647  return pgStatSharedRefAge != curage;
648 }
649 
650 static void
652 {
653  pgstat_entry_ref_hash_iterator i;
655  uint64 curage;
656 
658  Assert(curage != 0);
659 
660  /*
661  * Some entries have been dropped. Invalidate cache pointer to them.
662  */
663  pgstat_entry_ref_hash_start_iterate(pgStatEntryRefHash, &i);
664  while ((ent = pgstat_entry_ref_hash_iterate(pgStatEntryRefHash, &i)) != NULL)
665  {
666  PgStat_EntryRef *entry_ref = ent->entry_ref;
667 
668  Assert(!entry_ref->shared_stats ||
669  entry_ref->shared_stats->magic == 0xdeadbeef);
670 
671  if (!entry_ref->shared_entry->dropped)
672  continue;
673 
674  /* cannot gc shared ref that has pending data */
675  if (entry_ref->pending != NULL)
676  continue;
677 
678  pgstat_release_entry_ref(ent->key, entry_ref, false);
679  }
680 
681  pgStatSharedRefAge = curage;
682 }
683 
684 static void
686  Datum match_data)
687 {
688  pgstat_entry_ref_hash_iterator i;
690 
691  if (pgStatEntryRefHash == NULL)
692  return;
693 
694  pgstat_entry_ref_hash_start_iterate(pgStatEntryRefHash, &i);
695 
696  while ((ent = pgstat_entry_ref_hash_iterate(pgStatEntryRefHash, &i))
697  != NULL)
698  {
699  Assert(ent->entry_ref != NULL);
700 
701  if (match && !match(ent, match_data))
702  continue;
703 
704  pgstat_release_entry_ref(ent->key, ent->entry_ref, discard_pending);
705  }
706 }
707 
708 /*
709  * Release all local references to shared stats entries.
710  *
711  * When a process exits it cannot do so while still holding references onto
712  * stats entries, otherwise the shared stats entries could never be freed.
713  */
714 static void
715 pgstat_release_all_entry_refs(bool discard_pending)
716 {
717  if (pgStatEntryRefHash == NULL)
718  return;
719 
720  pgstat_release_matching_entry_refs(discard_pending, NULL, 0);
721  Assert(pgStatEntryRefHash->members == 0);
722  pgstat_entry_ref_hash_destroy(pgStatEntryRefHash);
723  pgStatEntryRefHash = NULL;
724 }
725 
726 static bool
728 {
729  Oid dboid = DatumGetObjectId(match_data);
730 
731  return ent->key.dboid == dboid;
732 }
733 
734 static void
736 {
737  pgstat_release_matching_entry_refs( /* discard pending = */ true,
738  match_db,
739  ObjectIdGetDatum(dboid));
740 }
741 
742 
743 /* ------------------------------------------------------------
744  * Dropping and resetting of stats entries
745  * ------------------------------------------------------------
746  */
747 
748 static void
750 {
751  dsa_pointer pdsa;
752 
753  /*
754  * Fetch dsa pointer before deleting entry - that way we can free the
755  * memory after releasing the lock.
756  */
757  pdsa = shent->body;
758 
759  if (!hstat)
761  else
762  dshash_delete_current(hstat);
763 
764  dsa_free(pgStatLocal.dsa, pdsa);
765 }
766 
767 /*
768  * Helper for both pgstat_drop_database_and_contents() and
769  * pgstat_drop_entry(). If hstat is non-null delete the shared entry using
770  * dshash_delete_current(), otherwise use dshash_delete_entry(). In either
771  * case the entry needs to be already locked.
772  */
773 static bool
775  dshash_seq_status *hstat)
776 {
777  Assert(shent->body != InvalidDsaPointer);
778 
779  /* should already have released local reference */
780  if (pgStatEntryRefHash)
781  Assert(!pgstat_entry_ref_hash_lookup(pgStatEntryRefHash, shent->key));
782 
783  /*
784  * Signal that the entry is dropped - this will eventually cause other
785  * backends to release their references.
786  */
787  if (shent->dropped)
788  elog(ERROR, "can only drop stats once");
789  shent->dropped = true;
790 
791  /* release refcount marking entry as not dropped */
792  if (pg_atomic_sub_fetch_u32(&shent->refcount, 1) == 0)
793  {
794  pgstat_free_entry(shent, hstat);
795  return true;
796  }
797  else
798  {
799  if (!hstat)
801  return false;
802  }
803 }
804 
805 /*
806  * Drop stats for the database and all the objects inside that database.
807  */
808 static void
810 {
811  dshash_seq_status hstat;
813  uint64 not_freed_count = 0;
814 
815  Assert(OidIsValid(dboid));
816 
817  Assert(pgStatLocal.shared_hash != NULL);
818 
819  /*
820  * This backend might very well be the only backend holding a reference to
821  * about-to-be-dropped entries. Ensure that we're not preventing it from
822  * being cleaned up till later.
823  *
824  * Doing this separately from the dshash iteration below avoids having to
825  * do so while holding a partition lock on the shared hashtable.
826  */
828 
829  /* some of the dshash entries are to be removed, take exclusive lock. */
830  dshash_seq_init(&hstat, pgStatLocal.shared_hash, true);
831  while ((p = dshash_seq_next(&hstat)) != NULL)
832  {
833  if (p->dropped)
834  continue;
835 
836  if (p->key.dboid != dboid)
837  continue;
838 
839  if (!pgstat_drop_entry_internal(p, &hstat))
840  {
841  /*
842  * Even statistics for a dropped database might currently be
843  * accessed (consider e.g. database stats for pg_stat_database).
844  */
845  not_freed_count++;
846  }
847  }
848  dshash_seq_term(&hstat);
849 
850  /*
851  * If some of the stats data could not be freed, signal the reference
852  * holders to run garbage collection of their cached pgStatShmLookupCache.
853  */
854  if (not_freed_count > 0)
856 }
857 
858 bool
859 pgstat_drop_entry(PgStat_Kind kind, Oid dboid, Oid objoid)
860 {
861  PgStat_HashKey key = {.kind = kind,.dboid = dboid,.objoid = objoid};
862  PgStatShared_HashEntry *shent;
863  bool freed = true;
864 
865  /* delete local reference */
866  if (pgStatEntryRefHash)
867  {
868  PgStat_EntryRefHashEntry *lohashent =
869  pgstat_entry_ref_hash_lookup(pgStatEntryRefHash, key);
870 
871  if (lohashent)
872  pgstat_release_entry_ref(lohashent->key, lohashent->entry_ref,
873  true);
874  }
875 
876  /* mark entry in shared hashtable as deleted, drop if possible */
877  shent = dshash_find(pgStatLocal.shared_hash, &key, true);
878  if (shent)
879  {
880  freed = pgstat_drop_entry_internal(shent, NULL);
881 
882  /*
883  * Database stats contain other stats. Drop those as well when
884  * dropping the database. XXX: Perhaps this should be done in a
885  * slightly more principled way? But not obvious what that'd look
886  * like, and so far this is the only case...
887  */
888  if (key.kind == PGSTAT_KIND_DATABASE)
890  }
891 
892  return freed;
893 }
894 
895 void
897 {
898  dshash_seq_status hstat;
900  uint64 not_freed_count = 0;
901 
902  dshash_seq_init(&hstat, pgStatLocal.shared_hash, true);
903  while ((ps = dshash_seq_next(&hstat)) != NULL)
904  {
905  if (ps->dropped)
906  continue;
907 
908  if (!pgstat_drop_entry_internal(ps, &hstat))
909  not_freed_count++;
910  }
911  dshash_seq_term(&hstat);
912 
913  if (not_freed_count > 0)
915 }
916 
917 static void
919  TimestampTz ts)
920 {
921  const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
922 
923  memset(pgstat_get_entry_data(kind, header), 0,
924  pgstat_get_entry_len(kind));
925 
926  if (kind_info->reset_timestamp_cb)
927  kind_info->reset_timestamp_cb(header, ts);
928 }
929 
930 /*
931  * Reset one variable-numbered stats entry.
932  */
933 void
935 {
936  PgStat_EntryRef *entry_ref;
937 
938  Assert(!pgstat_get_kind_info(kind)->fixed_amount);
939 
940  entry_ref = pgstat_get_entry_ref(kind, dboid, objoid, false, NULL);
941  if (!entry_ref || entry_ref->shared_entry->dropped)
942  return;
943 
944  (void) pgstat_lock_entry(entry_ref, false);
945  shared_stat_reset_contents(kind, entry_ref->shared_stats, ts);
946  pgstat_unlock_entry(entry_ref);
947 }
948 
949 /*
950  * Scan through the shared hashtable of stats, resetting statistics if
951  * approved by the provided do_reset() function.
952  */
953 void
955  Datum match_data, TimestampTz ts)
956 {
957  dshash_seq_status hstat;
959 
960  /* dshash entry is not modified, take shared lock */
961  dshash_seq_init(&hstat, pgStatLocal.shared_hash, false);
962  while ((p = dshash_seq_next(&hstat)) != NULL)
963  {
964  PgStatShared_Common *header;
965 
966  if (p->dropped)
967  continue;
968 
969  if (!do_reset(p, match_data))
970  continue;
971 
972  header = dsa_get_address(pgStatLocal.dsa, p->body);
973 
974  LWLockAcquire(&header->lock, LW_EXCLUSIVE);
975 
976  shared_stat_reset_contents(p->key.kind, header, ts);
977 
978  LWLockRelease(&header->lock);
979  }
980  dshash_seq_term(&hstat);
981 }
982 
983 static bool
985 {
986  return p->key.kind == DatumGetInt32(match_data);
987 }
988 
989 void
991 {
993 }
994 
995 static void
997 {
1001  "PgStat Shared Ref",
1006  "PgStat Shared Ref Hash",
1008 }
static uint32 pg_atomic_sub_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
Definition: atomics.h:434
static uint32 pg_atomic_fetch_sub_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
Definition: atomics.h:376
static void pg_atomic_init_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
Definition: atomics.h:216
static uint32 pg_atomic_fetch_add_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
Definition: atomics.h:361
static uint64 pg_atomic_fetch_add_u64(volatile pg_atomic_uint64 *ptr, int64 add_)
Definition: atomics.h:518
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
Definition: atomics.h:234
static void pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:448
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
Definition: atomics.h:462
#define likely(x)
Definition: c.h:310
#define MAXALIGN(LEN)
Definition: c.h:811
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:182
#define Assert(condition)
Definition: c.h:858
unsigned char bool
Definition: c.h:456
#define unlikely(x)
Definition: c.h:311
#define OidIsValid(objectId)
Definition: c.h:775
size_t Size
Definition: c.h:605
int64 TimestampTz
Definition: timestamp.h:39
void * dsa_get_address(dsa_area *area, dsa_pointer dp)
Definition: dsa.c:942
void dsa_set_size_limit(dsa_area *area, size_t limit)
Definition: dsa.c:1018
void dsa_pin_mapping(dsa_area *area)
Definition: dsa.c:635
void dsa_detach(dsa_area *area)
Definition: dsa.c:1952
dsa_area * dsa_attach_in_place(void *place, dsm_segment *segment)
Definition: dsa.c:545
void dsa_free(dsa_area *area, dsa_pointer dp)
Definition: dsa.c:826
size_t dsa_minimum_size(void)
Definition: dsa.c:1196
void dsa_pin(dsa_area *area)
Definition: dsa.c:975
#define dsa_allocate0(area, size)
Definition: dsa.h:113
#define dsa_create_in_place(place, size, tranch_id, segment)
Definition: dsa.h:122
uint64 dsa_pointer
Definition: dsa.h:62
#define InvalidDsaPointer
Definition: dsa.h:78
void dshash_memcpy(void *dest, const void *src, size_t size, void *arg)
Definition: dshash.c:590
void dshash_delete_entry(dshash_table *hash_table, void *entry)
Definition: dshash.c:541
void dshash_release_lock(dshash_table *hash_table, void *entry)
Definition: dshash.c:558
void dshash_detach(dshash_table *hash_table)
Definition: dshash.c:307
void dshash_seq_init(dshash_seq_status *status, dshash_table *hash_table, bool exclusive)
Definition: dshash.c:638
void * dshash_find(dshash_table *hash_table, const void *key, bool exclusive)
Definition: dshash.c:390
dshash_table_handle dshash_get_hash_table_handle(dshash_table *hash_table)
Definition: dshash.c:367
void dshash_seq_term(dshash_seq_status *status)
Definition: dshash.c:747
void * dshash_find_or_insert(dshash_table *hash_table, const void *key, bool *found)
Definition: dshash.c:433
dshash_table * dshash_attach(dsa_area *area, const dshash_parameters *params, dshash_table_handle handle, void *arg)
Definition: dshash.c:270
dshash_table * dshash_create(dsa_area *area, const dshash_parameters *params, void *arg)
Definition: dshash.c:206
void * dshash_seq_next(dshash_seq_status *status)
Definition: dshash.c:657
void dshash_delete_current(dshash_seq_status *status)
Definition: dshash.c:757
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
bool IsUnderPostmaster
Definition: globals.c:117
uint64 chunk
struct parser_state ps
int i
Definition: isn.c:73
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1170
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1783
void LWLockInitialize(LWLock *lock, int tranche_id)
Definition: lwlock.c:709
bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1341
@ LWTRANCHE_PGSTATS_HASH
Definition: lwlock.h:204
@ LWTRANCHE_PGSTATS_DSA
Definition: lwlock.h:203
@ LWTRANCHE_PGSTATS_DATA
Definition: lwlock.h:205
@ LW_SHARED
Definition: lwlock.h:115
@ LW_EXCLUSIVE
Definition: lwlock.h:114
void pfree(void *pointer)
Definition: mcxt.c:1520
MemoryContext TopMemoryContext
Definition: mcxt.c:149
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1180
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_SMALL_SIZES
Definition: memutils.h:170
#define BACKEND_NUM_TYPES
Definition: miscadmin.h:370
const void * data
const PgStat_KindInfo * pgstat_get_kind_info(PgStat_Kind kind)
Definition: pgstat.c:1263
void pgstat_delete_pending_entry(PgStat_EntryRef *entry_ref)
Definition: pgstat.c:1156
PgStat_LocalState pgStatLocal
Definition: pgstat.c:193
PgStat_Kind
Definition: pgstat.h:36
@ PGSTAT_KIND_DATABASE
Definition: pgstat.h:41
static uint32 pgstat_hash_hash_key(const void *d, size_t size, void *arg)
static int pgstat_cmp_hash_key(const void *a, const void *b, size_t size, void *arg)
static void * pgstat_get_entry_data(PgStat_Kind kind, PgStatShared_Common *entry)
#define pgstat_assert_is_up()
struct PgStat_HashKey PgStat_HashKey
static size_t pgstat_get_entry_len(PgStat_Kind kind)
static bool match_db(PgStat_EntryRefHashEntry *ent, Datum match_data)
Definition: pgstat_shmem.c:727
static void pgstat_setup_memcxt(void)
Definition: pgstat_shmem.c:996
void pgstat_reset_entries_of_kind(PgStat_Kind kind, TimestampTz ts)
Definition: pgstat_shmem.c:990
void pgstat_request_entry_refs_gc(void)
Definition: pgstat_shmem.c:629
static void pgstat_release_db_entry_refs(Oid dboid)
Definition: pgstat_shmem.c:735
PgStatShared_Common * pgstat_init_entry(PgStat_Kind kind, PgStatShared_HashEntry *shhashent)
Definition: pgstat_shmem.c:259
static Size pgstat_dsa_init_size(void)
Definition: pgstat_shmem.c:106
static bool match_kind(PgStatShared_HashEntry *p, Datum match_data)
Definition: pgstat_shmem.c:984
static MemoryContext pgStatEntryRefHashContext
Definition: pgstat_shmem.c:91
void StatsShmemInit(void)
Definition: pgstat_shmem.c:141
bool pgstat_lock_entry_shared(PgStat_EntryRef *entry_ref, bool nowait)
Definition: pgstat_shmem.c:592
void pgstat_attach_shmem(void)
Definition: pgstat_shmem.c:218
static void pgstat_free_entry(PgStatShared_HashEntry *shent, dshash_seq_status *hstat)
Definition: pgstat_shmem.c:749
static int pgStatSharedRefAge
Definition: pgstat_shmem.c:83
#define PGSTAT_ENTRY_REF_HASH_SIZE
Definition: pgstat_shmem.c:21
static void shared_stat_reset_contents(PgStat_Kind kind, PgStatShared_Common *header, TimestampTz ts)
Definition: pgstat_shmem.c:918
static void pgstat_setup_shared_refs(void)
Definition: pgstat_shmem.c:307
static void pgstat_release_entry_ref(PgStat_HashKey key, PgStat_EntryRef *entry_ref, bool discard_pending)
Definition: pgstat_shmem.c:522
static void pgstat_drop_database_and_contents(Oid dboid)
Definition: pgstat_shmem.c:809
static PgStatShared_Common * pgstat_reinit_entry(PgStat_Kind kind, PgStatShared_HashEntry *shhashent)
Definition: pgstat_shmem.c:288
static pgstat_entry_ref_hash_hash * pgStatEntryRefHash
Definition: pgstat_shmem.c:82
void pgstat_reset_entry(PgStat_Kind kind, Oid dboid, Oid objoid, TimestampTz ts)
Definition: pgstat_shmem.c:934
Size StatsShmemSize(void)
Definition: pgstat_shmem.c:127
static void pgstat_acquire_entry_ref(PgStat_EntryRef *entry_ref, PgStatShared_HashEntry *shhashent, PgStatShared_Common *shheader)
Definition: pgstat_shmem.c:323
static MemoryContext pgStatSharedRefContext
Definition: pgstat_shmem.c:90
void pgstat_reset_matching_entries(bool(*do_reset)(PgStatShared_HashEntry *, Datum), Datum match_data, TimestampTz ts)
Definition: pgstat_shmem.c:954
void pgstat_drop_all_entries(void)
Definition: pgstat_shmem.c:896
static const dshash_parameters dsh_params
Definition: pgstat_shmem.c:62
PgStat_EntryRef * pgstat_get_entry_ref(PgStat_Kind kind, Oid dboid, Oid objoid, bool create, bool *created_entry)
Definition: pgstat_shmem.c:398
static bool pgstat_get_entry_ref_cached(PgStat_HashKey key, PgStat_EntryRef **entry_ref_p)
Definition: pgstat_shmem.c:342
void pgstat_unlock_entry(PgStat_EntryRef *entry_ref)
Definition: pgstat_shmem.c:604
static void pgstat_release_all_entry_refs(bool discard_pending)
Definition: pgstat_shmem.c:715
struct PgStat_EntryRefHashEntry PgStat_EntryRefHashEntry
static void pgstat_release_matching_entry_refs(bool discard_pending, ReleaseMatchCB match, Datum match_data)
Definition: pgstat_shmem.c:685
bool(* ReleaseMatchCB)(PgStat_EntryRefHashEntry *, Datum data)
Definition: pgstat_shmem.c:55
bool pgstat_drop_entry(PgStat_Kind kind, Oid dboid, Oid objoid)
Definition: pgstat_shmem.c:859
bool pgstat_lock_entry(PgStat_EntryRef *entry_ref, bool nowait)
Definition: pgstat_shmem.c:576
static void pgstat_gc_entry_refs(void)
Definition: pgstat_shmem.c:651
static bool pgstat_need_entry_refs_gc(void)
Definition: pgstat_shmem.c:635
static bool pgstat_drop_entry_internal(PgStatShared_HashEntry *shent, dshash_seq_status *hstat)
Definition: pgstat_shmem.c:774
void pgstat_detach_shmem(void)
Definition: pgstat_shmem.c:238
PgStat_EntryRef * pgstat_get_entry_ref_locked(PgStat_Kind kind, Oid dboid, Oid objoid, bool nowait)
Definition: pgstat_shmem.c:613
uintptr_t Datum
Definition: postgres.h:64
static Oid DatumGetObjectId(Datum X)
Definition: postgres.h:242
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:212
static int32 DatumGetInt32(Datum X)
Definition: postgres.h:202
unsigned int Oid
Definition: postgres_ext.h:31
MemoryContextSwitchTo(old_ctx)
tree ctl
Definition: radixtree.h:1847
Size add_size(Size s1, Size s2)
Definition: shmem.c:493
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:387
Definition: lwlock.h:42
pg_atomic_uint32 refcount
PgStat_EntryRef * entry_ref
Definition: pgstat_shmem.c:28
PgStatShared_Common * shared_stats
PgStatShared_HashEntry * shared_entry
PgStat_Kind kind
void(* reset_timestamp_cb)(PgStatShared_Common *header, TimestampTz ts)
dshash_table * shared_hash
PgStat_ShmemControl * shmem
dshash_table_handle hash_handle
pg_atomic_uint64 gc_request_count
Definition: dsa.c:348