#include "postgres.h"
#include "pgstat.h"
#include "storage/shmem.h"
#include "utils/memutils.h"
#include "utils/pgstat_internal.h"
#include "lib/simplehash.h"

Include dependency graph for pgstat_shmem.c:

Go to the source code of this file.

Data Structures
struct	PgStat_EntryRefHashEntry

Macros
#define	PGSTAT_ENTRY_REF_HASH_SIZE 128

#define	SH_PREFIX pgstat_entry_ref_hash

#define	SH_ELEMENT_TYPE PgStat_EntryRefHashEntry

#define	SH_KEY_TYPE PgStat_HashKey

#define	SH_KEY key

#define	SH_HASH_KEY(tb, key) pgstat_hash_hash_key(&key, sizeof(PgStat_HashKey), NULL)

#define	SH_EQUAL(tb, a, b) pgstat_cmp_hash_key(&a, &b, sizeof(PgStat_HashKey), NULL) == 0

#define	SH_SCOPE static inline

#define	SH_DEFINE

#define	SH_DECLARE

Typedefs
typedef struct PgStat_EntryRefHashEntry	PgStat_EntryRefHashEntry

typedef bool(*	ReleaseMatchCB) (PgStat_EntryRefHashEntry *, Datum data)

Functions
static void	pgstat_drop_database_and_contents (Oid dboid)

static void	pgstat_free_entry (PgStatShared_HashEntry shent, dshash_seq_status hstat)

static void	pgstat_release_entry_ref (PgStat_HashKey key, PgStat_EntryRef *entry_ref, bool discard_pending)

static bool	pgstat_need_entry_refs_gc (void)

static void	pgstat_gc_entry_refs (void)

static void	pgstat_release_all_entry_refs (bool discard_pending)

static void	pgstat_release_matching_entry_refs (bool discard_pending, ReleaseMatchCB match, Datum match_data)

static void	pgstat_setup_memcxt (void)

static Size	pgstat_dsa_init_size (void)

Size	StatsShmemSize (void)

void	StatsShmemInit (void)

void	pgstat_attach_shmem (void)

void	pgstat_detach_shmem (void)

PgStatShared_Common *	pgstat_init_entry (PgStat_Kind kind, PgStatShared_HashEntry *shhashent)

static PgStatShared_Common *	pgstat_reinit_entry (PgStat_Kind kind, PgStatShared_HashEntry *shhashent)

static void	pgstat_setup_shared_refs (void)

static void	pgstat_acquire_entry_ref (PgStat_EntryRef entry_ref, PgStatShared_HashEntry shhashent, PgStatShared_Common *shheader)

static bool	pgstat_get_entry_ref_cached (PgStat_HashKey key, PgStat_EntryRef **entry_ref_p)

PgStat_EntryRef *	pgstat_get_entry_ref (PgStat_Kind kind, Oid dboid, Oid objoid, bool create, bool *created_entry)

bool	pgstat_lock_entry (PgStat_EntryRef *entry_ref, bool nowait)

bool	pgstat_lock_entry_shared (PgStat_EntryRef *entry_ref, bool nowait)

void	pgstat_unlock_entry (PgStat_EntryRef *entry_ref)

PgStat_EntryRef *	pgstat_get_entry_ref_locked (PgStat_Kind kind, Oid dboid, Oid objoid, bool nowait)

void	pgstat_request_entry_refs_gc (void)

static bool	match_db (PgStat_EntryRefHashEntry *ent, Datum match_data)

static void	pgstat_release_db_entry_refs (Oid dboid)

static bool	pgstat_drop_entry_internal (PgStatShared_HashEntry shent, dshash_seq_status hstat)

bool	pgstat_drop_entry (PgStat_Kind kind, Oid dboid, Oid objoid)

void	pgstat_drop_all_entries (void)

static void	shared_stat_reset_contents (PgStat_Kind kind, PgStatShared_Common *header, TimestampTz ts)

void	pgstat_reset_entry (PgStat_Kind kind, Oid dboid, Oid objoid, TimestampTz ts)

void	pgstat_reset_matching_entries (bool(do_reset)(PgStatShared_HashEntry , Datum), Datum match_data, TimestampTz ts)

static bool	match_kind (PgStatShared_HashEntry *p, Datum match_data)

void	pgstat_reset_entries_of_kind (PgStat_Kind kind, TimestampTz ts)

Variables
static const dshash_parameters	dsh_params

static pgstat_entry_ref_hash_hash *	pgStatEntryRefHash = NULL

static int	pgStatSharedRefAge = 0

static MemoryContext	pgStatSharedRefContext = NULL

static MemoryContext	pgStatEntryRefHashContext = NULL

Macro Definition Documentation

◆ PGSTAT_ENTRY_REF_HASH_SIZE

#define PGSTAT_ENTRY_REF_HASH_SIZE 128

Definition at line 21 of file pgstat_shmem.c.

◆ SH_DECLARE

#define SH_DECLARE

Definition at line 43 of file pgstat_shmem.c.

◆ SH_DEFINE

#define SH_DEFINE

Definition at line 42 of file pgstat_shmem.c.

◆ SH_ELEMENT_TYPE

#define SH_ELEMENT_TYPE PgStat_EntryRefHashEntry

Definition at line 34 of file pgstat_shmem.c.

◆ SH_EQUAL

#define SH_EQUAL	(	tb,
		a,
		b
	)	pgstat_cmp_hash_key(&a, &b, sizeof(PgStat_HashKey), NULL) == 0

Definition at line 39 of file pgstat_shmem.c.

◆ SH_HASH_KEY

#define SH_HASH_KEY	(	tb,
		key
	)	pgstat_hash_hash_key(&key, sizeof(PgStat_HashKey), NULL)

Definition at line 37 of file pgstat_shmem.c.

◆ SH_KEY

#define SH_KEY key

Definition at line 36 of file pgstat_shmem.c.

◆ SH_KEY_TYPE

#define SH_KEY_TYPE PgStat_HashKey

Definition at line 35 of file pgstat_shmem.c.

◆ SH_PREFIX

#define SH_PREFIX pgstat_entry_ref_hash

Definition at line 33 of file pgstat_shmem.c.

◆ SH_SCOPE

#define SH_SCOPE static inline

Definition at line 41 of file pgstat_shmem.c.

Typedef Documentation

◆ PgStat_EntryRefHashEntry

typedef struct PgStat_EntryRefHashEntry PgStat_EntryRefHashEntry

◆ ReleaseMatchCB

typedef bool(* ReleaseMatchCB) (PgStat_EntryRefHashEntry *, Datum data)

Definition at line 55 of file pgstat_shmem.c.

Function Documentation

◆ match_db()

static bool match_db	(	PgStat_EntryRefHashEntry *	ent,
		Datum	match_data
	)

static

Definition at line 726 of file pgstat_shmem.c.

 {
     Oid         dboid = DatumGetObjectId(match_data);
  
     return ent->key.dboid == dboid;
 }

References DatumGetObjectId(), PgStat_HashKey::dboid, and PgStat_EntryRefHashEntry::key.

Referenced by pgstat_release_db_entry_refs().

◆ match_kind()

static bool match_kind	(	PgStatShared_HashEntry *	p,
		Datum	match_data
	)

static

Definition at line 983 of file pgstat_shmem.c.

 {
     return p->key.kind == DatumGetInt32(match_data);
 }

References DatumGetInt32(), PgStatShared_HashEntry::key, and PgStat_HashKey::kind.

Referenced by pgstat_reset_entries_of_kind().

◆ pgstat_acquire_entry_ref()

static void pgstat_acquire_entry_ref	(	PgStat_EntryRef *	entry_ref,
		PgStatShared_HashEntry *	shhashent,
		PgStatShared_Common *	shheader
	)

static

Definition at line 322 of file pgstat_shmem.c.

 {
     Assert(shheader->magic == 0xdeadbeef);
     Assert(pg_atomic_read_u32(&shhashent->refcount) > 0);
  
     pg_atomic_fetch_add_u32(&shhashent->refcount, 1);
  
     dshash_release_lock(pgStatLocal.shared_hash, shhashent);
  
     entry_ref->shared_stats = shheader;
     entry_ref->shared_entry = shhashent;
 }

References Assert(), dshash_release_lock(), PgStatShared_Common::magic, pg_atomic_fetch_add_u32(), pg_atomic_read_u32(), pgStatLocal, PgStatShared_HashEntry::refcount, PgStat_EntryRef::shared_entry, PgStat_LocalState::shared_hash, and PgStat_EntryRef::shared_stats.

Referenced by pgstat_get_entry_ref().

◆ pgstat_attach_shmem()

void pgstat_attach_shmem ( void )

Definition at line 217 of file pgstat_shmem.c.

 {
     MemoryContext oldcontext;
  
     Assert(pgStatLocal.dsa == NULL);
  
     /* stats shared memory persists for the backend lifetime */
     oldcontext = MemoryContextSwitchTo(TopMemoryContext);
  
     pgStatLocal.dsa = dsa_attach_in_place(pgStatLocal.shmem->raw_dsa_area,
                                           NULL);
     dsa_pin_mapping(pgStatLocal.dsa);
  
     pgStatLocal.shared_hash = dshash_attach(pgStatLocal.dsa, &dsh_params,
                                             pgStatLocal.shmem->hash_handle, 0);
  
     MemoryContextSwitchTo(oldcontext);
 }

References Assert(), PgStat_LocalState::dsa, dsa_attach_in_place(), dsa_pin_mapping(), dsh_params, dshash_attach(), PgStat_ShmemControl::hash_handle, MemoryContextSwitchTo(), pgStatLocal, PgStat_ShmemControl::raw_dsa_area, PgStat_LocalState::shared_hash, PgStat_LocalState::shmem, and TopMemoryContext.

Referenced by pgstat_initialize().

◆ pgstat_detach_shmem()

void pgstat_detach_shmem ( void )

Definition at line 237 of file pgstat_shmem.c.

 {
     Assert(pgStatLocal.dsa);
  
     /* we shouldn't leave references to shared stats */
     pgstat_release_all_entry_refs(false);
  
     dshash_detach(pgStatLocal.shared_hash);
     pgStatLocal.shared_hash = NULL;
  
     dsa_detach(pgStatLocal.dsa);
     pgStatLocal.dsa = NULL;
 }

References Assert(), PgStat_LocalState::dsa, dsa_detach(), dshash_detach(), pgstat_release_all_entry_refs(), pgStatLocal, and PgStat_LocalState::shared_hash.

Referenced by pgstat_shutdown_hook().

◆ pgstat_drop_all_entries()

void pgstat_drop_all_entries ( void )

Definition at line 895 of file pgstat_shmem.c.

 {
     dshash_seq_status hstat;
     PgStatShared_HashEntry *ps;
     uint64      not_freed_count = 0;
  
     dshash_seq_init(&hstat, pgStatLocal.shared_hash, true);
     while ((ps = dshash_seq_next(&hstat)) != NULL)
     {
         if (ps->dropped)
             continue;
  
         if (!pgstat_drop_entry_internal(ps, &hstat))
             not_freed_count++;
     }
     dshash_seq_term(&hstat);
  
     if (not_freed_count > 0)
         pgstat_request_entry_refs_gc();
 }

References dshash_seq_init(), dshash_seq_next(), dshash_seq_term(), pgstat_drop_entry_internal(), pgstat_request_entry_refs_gc(), pgStatLocal, ps, and PgStat_LocalState::shared_hash.

Referenced by pgstat_reset_after_failure().

◆ pgstat_drop_database_and_contents()

static void pgstat_drop_database_and_contents ( Oid dboid )

static

Definition at line 808 of file pgstat_shmem.c.

 {
     dshash_seq_status hstat;
     PgStatShared_HashEntry *p;
     uint64      not_freed_count = 0;
  
     Assert(OidIsValid(dboid));
  
     Assert(pgStatLocal.shared_hash != NULL);
  
     /*
      * This backend might very well be the only backend holding a reference to
      * about-to-be-dropped entries. Ensure that we're not preventing it from
      * being cleaned up till later.
      *
      * Doing this separately from the dshash iteration below avoids having to
      * do so while holding a partition lock on the shared hashtable.
      */
     pgstat_release_db_entry_refs(dboid);
  
     /* some of the dshash entries are to be removed, take exclusive lock. */
     dshash_seq_init(&hstat, pgStatLocal.shared_hash, true);
     while ((p = dshash_seq_next(&hstat)) != NULL)
     {
         if (p->dropped)
             continue;
  
         if (p->key.dboid != dboid)
             continue;
  
         if (!pgstat_drop_entry_internal(p, &hstat))
         {
             /*
              * Even statistics for a dropped database might currently be
              * accessed (consider e.g. database stats for pg_stat_database).
              */
             not_freed_count++;
         }
     }
     dshash_seq_term(&hstat);
  
     /*
      * If some of the stats data could not be freed, signal the reference
      * holders to run garbage collection of their cached pgStatShmLookupCache.
      */
     if (not_freed_count > 0)
         pgstat_request_entry_refs_gc();
 }

References Assert(), PgStat_HashKey::dboid, PgStatShared_HashEntry::dropped, dshash_seq_init(), dshash_seq_next(), dshash_seq_term(), PgStatShared_HashEntry::key, OidIsValid, pgstat_drop_entry_internal(), pgstat_release_db_entry_refs(), pgstat_request_entry_refs_gc(), pgStatLocal, and PgStat_LocalState::shared_hash.

Referenced by pgstat_drop_entry().

◆ pgstat_drop_entry()

bool pgstat_drop_entry	(	PgStat_Kind	kind,
		Oid	dboid,
		Oid	objoid
	)

Definition at line 858 of file pgstat_shmem.c.

 {
     PgStat_HashKey key = {.kind = kind,.dboid = dboid,.objoid = objoid};
     PgStatShared_HashEntry *shent;
     bool        freed = true;
  
     /* delete local reference */
     if (pgStatEntryRefHash)
     {
         PgStat_EntryRefHashEntry *lohashent =
         pgstat_entry_ref_hash_lookup(pgStatEntryRefHash, key);
  
         if (lohashent)
             pgstat_release_entry_ref(lohashent->key, lohashent->entry_ref,
                                      true);
     }
  
     /* mark entry in shared hashtable as deleted, drop if possible */
     shent = dshash_find(pgStatLocal.shared_hash, &key, true);
     if (shent)
     {
         freed = pgstat_drop_entry_internal(shent, NULL);
  
         /*
          * Database stats contain other stats. Drop those as well when
          * dropping the database. XXX: Perhaps this should be done in a
          * slightly more principled way? But not obvious what that'd look
          * like, and so far this is the only case...
          */
         if (key.kind == PGSTAT_KIND_DATABASE)
             pgstat_drop_database_and_contents(key.dboid);
     }
  
     return freed;
 }

References dshash_find(), PgStat_EntryRefHashEntry::entry_ref, PgStat_EntryRefHashEntry::key, sort-test::key, pgstat_drop_database_and_contents(), pgstat_drop_entry_internal(), PGSTAT_KIND_DATABASE, pgstat_release_entry_ref(), pgStatEntryRefHash, pgStatLocal, and PgStat_LocalState::shared_hash.

Referenced by AtEOSubXact_PgStat_DroppedStats(), AtEOXact_PgStat_DroppedStats(), pgstat_drop_replslot(), pgstat_execute_transactional_drops(), and pgstat_init_function_usage().

◆ pgstat_drop_entry_internal()

static bool pgstat_drop_entry_internal	(	PgStatShared_HashEntry *	shent,
		dshash_seq_status *	hstat
	)

static

Definition at line 773 of file pgstat_shmem.c.

 {
     Assert(shent->body != InvalidDsaPointer);
  
     /* should already have released local reference */
     if (pgStatEntryRefHash)
         Assert(!pgstat_entry_ref_hash_lookup(pgStatEntryRefHash, shent->key));
  
     /*
      * Signal that the entry is dropped - this will eventually cause other
      * backends to release their references.
      */
     if (shent->dropped)
         elog(ERROR, "can only drop stats once");
     shent->dropped = true;
  
     /* release refcount marking entry as not dropped */
     if (pg_atomic_sub_fetch_u32(&shent->refcount, 1) == 0)
     {
         pgstat_free_entry(shent, hstat);
         return true;
     }
     else
     {
         if (!hstat)
             dshash_release_lock(pgStatLocal.shared_hash, shent);
         return false;
     }
 }

References Assert(), PgStatShared_HashEntry::body, PgStatShared_HashEntry::dropped, dshash_release_lock(), elog(), ERROR, InvalidDsaPointer, PgStatShared_HashEntry::key, pg_atomic_sub_fetch_u32(), pgstat_free_entry(), pgStatEntryRefHash, pgStatLocal, PgStatShared_HashEntry::refcount, and PgStat_LocalState::shared_hash.

Referenced by pgstat_drop_all_entries(), pgstat_drop_database_and_contents(), and pgstat_drop_entry().

◆ pgstat_dsa_init_size()

static Size pgstat_dsa_init_size ( void )

static

Definition at line 105 of file pgstat_shmem.c.

 {
     Size        sz;
  
     /*
      * The dshash header / initial buckets array needs to fit into "plain"
      * shared memory, but it's beneficial to not need dsm segments
      * immediately. A size of 256kB seems works well and is not
      * disproportional compared to other constant sized shared memory
      * allocations. NB: To avoid DSMs further, the user can configure
      * min_dynamic_shared_memory.
      */
     sz = 256 * 1024;
     Assert(dsa_minimum_size() <= sz);
     return MAXALIGN(sz);
 }

References Assert(), dsa_minimum_size(), and MAXALIGN.

Referenced by StatsShmemInit(), and StatsShmemSize().

◆ pgstat_free_entry()

static void pgstat_free_entry	(	PgStatShared_HashEntry *	shent,
		dshash_seq_status *	hstat
	)

static

Definition at line 748 of file pgstat_shmem.c.

 {
     dsa_pointer pdsa;
  
     /*
      * Fetch dsa pointer before deleting entry - that way we can free the
      * memory after releasing the lock.
      */
     pdsa = shent->body;
  
     if (!hstat)
         dshash_delete_entry(pgStatLocal.shared_hash, shent);
     else
         dshash_delete_current(hstat);
  
     dsa_free(pgStatLocal.dsa, pdsa);
 }

References PgStatShared_HashEntry::body, PgStat_LocalState::dsa, dsa_free(), dshash_delete_current(), dshash_delete_entry(), pgStatLocal, and PgStat_LocalState::shared_hash.

Referenced by pgstat_drop_entry_internal(), and pgstat_release_entry_ref().

◆ pgstat_gc_entry_refs()

static void pgstat_gc_entry_refs ( void )

static

Definition at line 650 of file pgstat_shmem.c.

 {
     pgstat_entry_ref_hash_iterator i;
     PgStat_EntryRefHashEntry *ent;
     uint64      curage;
  
     curage = pg_atomic_read_u64(&pgStatLocal.shmem->gc_request_count);
     Assert(curage != 0);
  
     /*
      * Some entries have been dropped. Invalidate cache pointer to them.
      */
     pgstat_entry_ref_hash_start_iterate(pgStatEntryRefHash, &i);
     while ((ent = pgstat_entry_ref_hash_iterate(pgStatEntryRefHash, &i)) != NULL)
     {
         PgStat_EntryRef *entry_ref = ent->entry_ref;
  
         Assert(!entry_ref->shared_stats ||
                entry_ref->shared_stats->magic == 0xdeadbeef);
  
         if (!entry_ref->shared_entry->dropped)
             continue;
  
         /* cannot gc shared ref that has pending data */
         if (entry_ref->pending != NULL)
             continue;
  
         pgstat_release_entry_ref(ent->key, entry_ref, false);
     }
  
     pgStatSharedRefAge = curage;
 }

References Assert(), PgStatShared_HashEntry::dropped, PgStat_EntryRefHashEntry::entry_ref, PgStat_ShmemControl::gc_request_count, i, PgStat_EntryRefHashEntry::key, PgStatShared_Common::magic, PgStat_EntryRef::pending, pg_atomic_read_u64(), pgstat_release_entry_ref(), pgStatEntryRefHash, pgStatLocal, pgStatSharedRefAge, PgStat_EntryRef::shared_entry, PgStat_EntryRef::shared_stats, and PgStat_LocalState::shmem.

Referenced by pgstat_get_entry_ref().

◆ pgstat_get_entry_ref()

PgStat_EntryRef* pgstat_get_entry_ref	(	PgStat_Kind	kind,
		Oid	dboid,
		Oid	objoid,
		bool	create,
		bool *	created_entry
	)

Definition at line 397 of file pgstat_shmem.c.

 {
     PgStat_HashKey key = {.kind = kind,.dboid = dboid,.objoid = objoid};
     PgStatShared_HashEntry *shhashent;
     PgStatShared_Common *shheader = NULL;
     PgStat_EntryRef *entry_ref;
  
     /*
      * passing in created_entry only makes sense if we possibly could create
      * entry.
      */
     Assert(create || created_entry == NULL);
     pgstat_assert_is_up();
     Assert(pgStatLocal.shared_hash != NULL);
     Assert(!pgStatLocal.shmem->is_shutdown);
  
     pgstat_setup_memcxt();
     pgstat_setup_shared_refs();
  
     if (created_entry != NULL)
         *created_entry = false;
  
     /*
      * Check if other backends dropped stats that could not be deleted because
      * somebody held references to it. If so, check this backend's references.
      * This is not expected to happen often. The location of the check is a
      * bit random, but this is a relatively frequently called path, so better
      * than most.
      */
     if (pgstat_need_entry_refs_gc())
         pgstat_gc_entry_refs();
  
     /*
      * First check the lookup cache hashtable in local memory. If we find a
      * match here we can avoid taking locks / causing contention.
      */
     if (pgstat_get_entry_ref_cached(key, &entry_ref))
         return entry_ref;
  
     Assert(entry_ref != NULL);
  
     /*
      * Do a lookup in the hash table first - it's quite likely that the entry
      * already exists, and that way we only need a shared lock.
      */
     shhashent = dshash_find(pgStatLocal.shared_hash, &key, false);
  
     if (create && !shhashent)
     {
         bool        shfound;
  
         /*
          * It's possible that somebody created the entry since the above
          * lookup. If so, fall through to the same path as if we'd have if it
          * already had been created before the dshash_find() calls.
          */
         shhashent = dshash_find_or_insert(pgStatLocal.shared_hash, &key, &shfound);
         if (!shfound)
         {
             shheader = pgstat_init_entry(kind, shhashent);
             pgstat_acquire_entry_ref(entry_ref, shhashent, shheader);
  
             if (created_entry != NULL)
                 *created_entry = true;
  
             return entry_ref;
         }
     }
  
     if (!shhashent)
     {
         /*
          * If we're not creating, delete the reference again. In all
          * likelihood it's just a stats lookup - no point wasting memory for a
          * shared ref to nothing...
          */
         pgstat_release_entry_ref(key, entry_ref, false);
  
         return NULL;
     }
     else
     {
         /*
          * Can get here either because dshash_find() found a match, or if
          * dshash_find_or_insert() found a concurrently inserted entry.
          */
  
         if (shhashent->dropped && create)
         {
             /*
              * There are legitimate cases where the old stats entry might not
              * yet have been dropped by the time it's reused. The most obvious
              * case are replication slot stats, where a new slot can be
              * created with the same index just after dropping. But oid
              * wraparound can lead to other cases as well. We just reset the
              * stats to their plain state.
              */
             shheader = pgstat_reinit_entry(kind, shhashent);
             pgstat_acquire_entry_ref(entry_ref, shhashent, shheader);
  
             if (created_entry != NULL)
                 *created_entry = true;
  
             return entry_ref;
         }
         else if (shhashent->dropped)
         {
             dshash_release_lock(pgStatLocal.shared_hash, shhashent);
             pgstat_release_entry_ref(key, entry_ref, false);
  
             return NULL;
         }
         else
         {
             shheader = dsa_get_address(pgStatLocal.dsa, shhashent->body);
             pgstat_acquire_entry_ref(entry_ref, shhashent, shheader);
  
             return entry_ref;
         }
     }
 }

References Assert(), PgStatShared_HashEntry::body, PgStatShared_HashEntry::dropped, PgStat_LocalState::dsa, dsa_get_address(), dshash_find(), dshash_find_or_insert(), dshash_release_lock(), PgStat_ShmemControl::is_shutdown, sort-test::key, pgstat_acquire_entry_ref(), pgstat_assert_is_up, pgstat_gc_entry_refs(), pgstat_get_entry_ref_cached(), pgstat_init_entry(), pgstat_need_entry_refs_gc(), pgstat_reinit_entry(), pgstat_release_entry_ref(), pgstat_setup_memcxt(), pgstat_setup_shared_refs(), pgStatLocal, PgStat_LocalState::shared_hash, and PgStat_LocalState::shmem.

Referenced by pgstat_acquire_replslot(), pgstat_create_subscription(), pgstat_create_transactional(), pgstat_fetch_entry(), pgstat_fetch_pending_entry(), pgstat_get_entry_ref_locked(), pgstat_have_entry(), pgstat_prep_pending_entry(), and pgstat_reset_entry().

◆ pgstat_get_entry_ref_cached()

static bool pgstat_get_entry_ref_cached	(	PgStat_HashKey	key,
		PgStat_EntryRef **	entry_ref_p
	)

static

Definition at line 341 of file pgstat_shmem.c.

 {
     bool        found;
     PgStat_EntryRefHashEntry *cache_entry;
  
     /*
      * We immediately insert a cache entry, because it avoids 1) multiple
      * hashtable lookups in case of a cache miss 2) having to deal with
      * out-of-memory errors after incrementing PgStatShared_Common->refcount.
      */
  
     cache_entry = pgstat_entry_ref_hash_insert(pgStatEntryRefHash, key, &found);
  
     if (!found || !cache_entry->entry_ref)
     {
         PgStat_EntryRef *entry_ref;
  
         cache_entry->entry_ref = entry_ref =
             MemoryContextAlloc(pgStatSharedRefContext,
                                sizeof(PgStat_EntryRef));
         entry_ref->shared_stats = NULL;
         entry_ref->shared_entry = NULL;
         entry_ref->pending = NULL;
  
         found = false;
     }
     else if (cache_entry->entry_ref->shared_stats == NULL)
     {
         Assert(cache_entry->entry_ref->pending == NULL);
         found = false;
     }
     else
     {
         PgStat_EntryRef *entry_ref PG_USED_FOR_ASSERTS_ONLY;
  
         entry_ref = cache_entry->entry_ref;
         Assert(entry_ref->shared_entry != NULL);
         Assert(entry_ref->shared_stats != NULL);
  
         Assert(entry_ref->shared_stats->magic == 0xdeadbeef);
         /* should have at least our reference */
         Assert(pg_atomic_read_u32(&entry_ref->shared_entry->refcount) > 0);
     }
  
     *entry_ref_p = cache_entry->entry_ref;
     return found;
 }

References Assert(), PgStat_EntryRefHashEntry::entry_ref, sort-test::key, MemoryContextAlloc(), PgStat_EntryRef::pending, pg_atomic_read_u32(), PG_USED_FOR_ASSERTS_ONLY, pgStatEntryRefHash, pgStatSharedRefContext, PgStat_EntryRef::shared_entry, and PgStat_EntryRef::shared_stats.

Referenced by pgstat_get_entry_ref().

◆ pgstat_get_entry_ref_locked()

PgStat_EntryRef* pgstat_get_entry_ref_locked	(	PgStat_Kind	kind,
		Oid	dboid,
		Oid	objoid,
		bool	nowait
	)

Definition at line 612 of file pgstat_shmem.c.

 {
     PgStat_EntryRef *entry_ref;
  
     /* find shared table stats entry corresponding to the local entry */
     entry_ref = pgstat_get_entry_ref(kind, dboid, objoid, true, NULL);
  
     /* lock the shared entry to protect the content, skip if failed */
     if (!pgstat_lock_entry(entry_ref, nowait))
         return NULL;
  
     return entry_ref;
 }

References pgstat_get_entry_ref(), and pgstat_lock_entry().

Referenced by pgstat_copy_relation_stats(), pgstat_create_replslot(), pgstat_report_analyze(), pgstat_report_autovac(), pgstat_report_checksum_failures_in_db(), pgstat_report_replslot(), pgstat_report_vacuum(), and pgstat_reset_database_timestamp().

◆ pgstat_init_entry()

PgStatShared_Common* pgstat_init_entry	(	PgStat_Kind	kind,
		PgStatShared_HashEntry *	shhashent
	)

Definition at line 258 of file pgstat_shmem.c.

 {
     /* Create new stats entry. */
     dsa_pointer chunk;
     PgStatShared_Common *shheader;
  
     /*
      * Initialize refcount to 1, marking it as valid / not dropped. The entry
      * can't be freed before the initialization because it can't be found as
      * long as we hold the dshash partition lock. Caller needs to increase
      * further if a longer lived reference is needed.
      */
     pg_atomic_init_u32(&shhashent->refcount, 1);
     shhashent->dropped = false;
  
     chunk = dsa_allocate0(pgStatLocal.dsa, pgstat_get_kind_info(kind)->shared_size);
     shheader = dsa_get_address(pgStatLocal.dsa, chunk);
     shheader->magic = 0xdeadbeef;
  
     /* Link the new entry from the hash entry. */
     shhashent->body = chunk;
  
     LWLockInitialize(&shheader->lock, LWTRANCHE_PGSTATS_DATA);
  
     return shheader;
 }

References PgStatShared_HashEntry::body, PgStatShared_HashEntry::dropped, PgStat_LocalState::dsa, dsa_allocate0, dsa_get_address(), PgStatShared_Common::lock, LWLockInitialize(), LWTRANCHE_PGSTATS_DATA, PgStatShared_Common::magic, pg_atomic_init_u32(), pgstat_get_kind_info(), pgStatLocal, and PgStatShared_HashEntry::refcount.

Referenced by pgstat_get_entry_ref(), and pgstat_read_statsfile().

◆ pgstat_lock_entry()

bool pgstat_lock_entry	(	PgStat_EntryRef *	entry_ref,
		bool	nowait
	)

Definition at line 575 of file pgstat_shmem.c.

 {
     LWLock     *lock = &entry_ref->shared_stats->lock;
  
     if (nowait)
         return LWLockConditionalAcquire(lock, LW_EXCLUSIVE);
  
     LWLockAcquire(lock, LW_EXCLUSIVE);
     return true;
 }

References PgStatShared_Common::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockConditionalAcquire(), and PgStat_EntryRef::shared_stats.

Referenced by pgstat_database_flush_cb(), pgstat_function_flush_cb(), pgstat_get_entry_ref_locked(), pgstat_relation_flush_cb(), pgstat_reset_entry(), and pgstat_subscription_flush_cb().

◆ pgstat_lock_entry_shared()

bool pgstat_lock_entry_shared	(	PgStat_EntryRef *	entry_ref,
		bool	nowait
	)

Definition at line 591 of file pgstat_shmem.c.

 {
     LWLock     *lock = &entry_ref->shared_stats->lock;
  
     if (nowait)
         return LWLockConditionalAcquire(lock, LW_SHARED);
  
     LWLockAcquire(lock, LW_SHARED);
     return true;
 }

References PgStatShared_Common::lock, LW_SHARED, LWLockAcquire(), LWLockConditionalAcquire(), and PgStat_EntryRef::shared_stats.

Referenced by pgstat_fetch_entry().

◆ pgstat_need_entry_refs_gc()

static bool pgstat_need_entry_refs_gc ( void )

static

Definition at line 634 of file pgstat_shmem.c.

 {
     uint64      curage;
  
     if (!pgStatEntryRefHash)
         return false;
  
     /* should have been initialized when creating pgStatEntryRefHash */
     Assert(pgStatSharedRefAge != 0);
  
     curage = pg_atomic_read_u64(&pgStatLocal.shmem->gc_request_count);
  
     return pgStatSharedRefAge != curage;
 }

References Assert(), PgStat_ShmemControl::gc_request_count, pg_atomic_read_u64(), pgStatEntryRefHash, pgStatLocal, pgStatSharedRefAge, and PgStat_LocalState::shmem.

Referenced by pgstat_get_entry_ref().

◆ pgstat_reinit_entry()

static PgStatShared_Common* pgstat_reinit_entry	(	PgStat_Kind	kind,
		PgStatShared_HashEntry *	shhashent
	)

static

Definition at line 287 of file pgstat_shmem.c.

 {
     PgStatShared_Common *shheader;
  
     shheader = dsa_get_address(pgStatLocal.dsa, shhashent->body);
  
     /* mark as not dropped anymore */
     pg_atomic_fetch_add_u32(&shhashent->refcount, 1);
     shhashent->dropped = false;
  
     /* reinitialize content */
     Assert(shheader->magic == 0xdeadbeef);
     memset(pgstat_get_entry_data(kind, shheader), 0,
            pgstat_get_entry_len(kind));
  
     return shheader;
 }

References Assert(), PgStatShared_HashEntry::body, PgStatShared_HashEntry::dropped, PgStat_LocalState::dsa, dsa_get_address(), PgStatShared_Common::magic, pg_atomic_fetch_add_u32(), pgstat_get_entry_data(), pgstat_get_entry_len(), pgStatLocal, and PgStatShared_HashEntry::refcount.

Referenced by pgstat_get_entry_ref().

◆ pgstat_release_all_entry_refs()

static void pgstat_release_all_entry_refs ( bool discard_pending )

static

Definition at line 714 of file pgstat_shmem.c.

 {
     if (pgStatEntryRefHash == NULL)
         return;
  
     pgstat_release_matching_entry_refs(discard_pending, NULL, 0);
     Assert(pgStatEntryRefHash->members == 0);
     pgstat_entry_ref_hash_destroy(pgStatEntryRefHash);
     pgStatEntryRefHash = NULL;
 }

References Assert(), pgstat_release_matching_entry_refs(), and pgStatEntryRefHash.

Referenced by pgstat_detach_shmem().

◆ pgstat_release_db_entry_refs()

static void pgstat_release_db_entry_refs ( Oid dboid )

static

Definition at line 734 of file pgstat_shmem.c.

 {
     pgstat_release_matching_entry_refs( /* discard pending = */ true,
                                        match_db,
                                        ObjectIdGetDatum(dboid));
 }

References match_db(), ObjectIdGetDatum(), and pgstat_release_matching_entry_refs().

Referenced by pgstat_drop_database_and_contents().

◆ pgstat_release_entry_ref()

static void pgstat_release_entry_ref	(	PgStat_HashKey	key,
		PgStat_EntryRef *	entry_ref,
		bool	discard_pending
	)

static

Definition at line 521 of file pgstat_shmem.c.

 {
     if (entry_ref && entry_ref->pending)
     {
         if (discard_pending)
             pgstat_delete_pending_entry(entry_ref);
         else
             elog(ERROR, "releasing ref with pending data");
     }
  
     if (entry_ref && entry_ref->shared_stats)
     {
         Assert(entry_ref->shared_stats->magic == 0xdeadbeef);
         Assert(entry_ref->pending == NULL);
  
         /*
          * This can't race with another backend looking up the stats entry and
          * increasing the refcount because it is not "legal" to create
          * additional references to dropped entries.
          */
         if (pg_atomic_fetch_sub_u32(&entry_ref->shared_entry->refcount, 1) == 1)
         {
             PgStatShared_HashEntry *shent;
  
             /*
              * We're the last referrer to this entry, try to drop the shared
              * entry.
              */
  
             /* only dropped entries can reach a 0 refcount */
             Assert(entry_ref->shared_entry->dropped);
  
             shent = dshash_find(pgStatLocal.shared_hash,
                                 &entry_ref->shared_entry->key,
                                 true);
             if (!shent)
                 elog(ERROR, "could not find just referenced shared stats entry");
  
             Assert(pg_atomic_read_u32(&entry_ref->shared_entry->refcount) == 0);
             Assert(entry_ref->shared_entry == shent);
  
             pgstat_free_entry(shent, NULL);
         }
     }
  
     if (!pgstat_entry_ref_hash_delete(pgStatEntryRefHash, key))
         elog(ERROR, "entry ref vanished before deletion");
  
     if (entry_ref)
         pfree(entry_ref);
 }

References Assert(), PgStatShared_HashEntry::dropped, dshash_find(), elog(), ERROR, PgStatShared_HashEntry::key, sort-test::key, PgStatShared_Common::magic, PgStat_EntryRef::pending, pfree(), pg_atomic_fetch_sub_u32(), pg_atomic_read_u32(), pgstat_delete_pending_entry(), pgstat_free_entry(), pgStatEntryRefHash, pgStatLocal, PgStatShared_HashEntry::refcount, PgStat_EntryRef::shared_entry, PgStat_LocalState::shared_hash, and PgStat_EntryRef::shared_stats.

Referenced by pgstat_drop_entry(), pgstat_gc_entry_refs(), pgstat_get_entry_ref(), and pgstat_release_matching_entry_refs().

◆ pgstat_release_matching_entry_refs()

static void pgstat_release_matching_entry_refs	(	bool	discard_pending,
		ReleaseMatchCB	match,
		Datum	match_data
	)

static

Definition at line 684 of file pgstat_shmem.c.

 {
     pgstat_entry_ref_hash_iterator i;
     PgStat_EntryRefHashEntry *ent;
  
     if (pgStatEntryRefHash == NULL)
         return;
  
     pgstat_entry_ref_hash_start_iterate(pgStatEntryRefHash, &i);
  
     while ((ent = pgstat_entry_ref_hash_iterate(pgStatEntryRefHash, &i))
            != NULL)
     {
         Assert(ent->entry_ref != NULL);
  
         if (match && !match(ent, match_data))
             continue;
  
         pgstat_release_entry_ref(ent->key, ent->entry_ref, discard_pending);
     }
 }

References Assert(), PgStat_EntryRefHashEntry::entry_ref, i, PgStat_EntryRefHashEntry::key, pgstat_release_entry_ref(), and pgStatEntryRefHash.

Referenced by pgstat_release_all_entry_refs(), and pgstat_release_db_entry_refs().

◆ pgstat_request_entry_refs_gc()

void pgstat_request_entry_refs_gc ( void )

Definition at line 628 of file pgstat_shmem.c.

 {
     pg_atomic_fetch_add_u64(&pgStatLocal.shmem->gc_request_count, 1);
 }

References PgStat_ShmemControl::gc_request_count, pg_atomic_fetch_add_u64(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by AtEOSubXact_PgStat_DroppedStats(), AtEOXact_PgStat_DroppedStats(), pgstat_drop_all_entries(), pgstat_drop_database_and_contents(), and pgstat_execute_transactional_drops().

◆ pgstat_reset_entries_of_kind()

void pgstat_reset_entries_of_kind	(	PgStat_Kind	kind,
		TimestampTz	ts
	)

Definition at line 989 of file pgstat_shmem.c.

 {
     pgstat_reset_matching_entries(match_kind, Int32GetDatum(kind), ts);
 }

References Int32GetDatum(), match_kind(), and pgstat_reset_matching_entries().

Referenced by pgstat_reset_of_kind().

◆ pgstat_reset_entry()

void pgstat_reset_entry	(	PgStat_Kind	kind,
		Oid	dboid,
		Oid	objoid,
		TimestampTz	ts
	)

Definition at line 933 of file pgstat_shmem.c.

 {
     PgStat_EntryRef *entry_ref;
  
     Assert(!pgstat_get_kind_info(kind)->fixed_amount);
  
     entry_ref = pgstat_get_entry_ref(kind, dboid, objoid, false, NULL);
     if (!entry_ref || entry_ref->shared_entry->dropped)
         return;
  
     (void) pgstat_lock_entry(entry_ref, false);
     shared_stat_reset_contents(kind, entry_ref->shared_stats, ts);
     pgstat_unlock_entry(entry_ref);
 }

References Assert(), PgStatShared_HashEntry::dropped, pgstat_get_entry_ref(), pgstat_get_kind_info(), pgstat_lock_entry(), pgstat_unlock_entry(), PgStat_EntryRef::shared_entry, shared_stat_reset_contents(), and PgStat_EntryRef::shared_stats.

Referenced by pgstat_create_subscription(), and pgstat_reset().

◆ pgstat_reset_matching_entries()

void pgstat_reset_matching_entries	(	bool()(PgStatShared_HashEntry , Datum)	do_reset,
		Datum	match_data,
		TimestampTz	ts
	)

Definition at line 953 of file pgstat_shmem.c.

 {
     dshash_seq_status hstat;
     PgStatShared_HashEntry *p;
  
     /* dshash entry is not modified, take shared lock */
     dshash_seq_init(&hstat, pgStatLocal.shared_hash, false);
     while ((p = dshash_seq_next(&hstat)) != NULL)
     {
         PgStatShared_Common *header;
  
         if (p->dropped)
             continue;
  
         if (!do_reset(p, match_data))
             continue;
  
         header = dsa_get_address(pgStatLocal.dsa, p->body);
  
         LWLockAcquire(&header->lock, LW_EXCLUSIVE);
  
         shared_stat_reset_contents(p->key.kind, header, ts);
  
         LWLockRelease(&header->lock);
     }
     dshash_seq_term(&hstat);
 }

References PgStatShared_HashEntry::body, PgStatShared_HashEntry::dropped, PgStat_LocalState::dsa, dsa_get_address(), dshash_seq_init(), dshash_seq_next(), dshash_seq_term(), header(), PgStatShared_HashEntry::key, PgStat_HashKey::kind, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), pgStatLocal, PgStat_LocalState::shared_hash, and shared_stat_reset_contents().

Referenced by pgstat_reset_counters(), and pgstat_reset_entries_of_kind().

◆ pgstat_setup_memcxt()

static void pgstat_setup_memcxt ( void )

static

Definition at line 995 of file pgstat_shmem.c.

 {
     if (unlikely(!pgStatSharedRefContext))
         pgStatSharedRefContext =
             AllocSetContextCreate(TopMemoryContext,
                                   "PgStat Shared Ref",
                                   ALLOCSET_SMALL_SIZES);
     if (unlikely(!pgStatEntryRefHashContext))
         pgStatEntryRefHashContext =
             AllocSetContextCreate(TopMemoryContext,
                                   "PgStat Shared Ref Hash",
                                   ALLOCSET_SMALL_SIZES);
 }

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, pgStatEntryRefHashContext, pgStatSharedRefContext, TopMemoryContext, and unlikely.

Referenced by pgstat_get_entry_ref().

◆ pgstat_setup_shared_refs()

static void pgstat_setup_shared_refs ( void )

static

Definition at line 306 of file pgstat_shmem.c.

 {
     if (likely(pgStatEntryRefHash != NULL))
         return;
  
     pgStatEntryRefHash =
         pgstat_entry_ref_hash_create(pgStatEntryRefHashContext,
                                      PGSTAT_ENTRY_REF_HASH_SIZE, NULL);
     pgStatSharedRefAge = pg_atomic_read_u64(&pgStatLocal.shmem->gc_request_count);
     Assert(pgStatSharedRefAge != 0);
 }

References Assert(), PgStat_ShmemControl::gc_request_count, likely, pg_atomic_read_u64(), PGSTAT_ENTRY_REF_HASH_SIZE, pgStatEntryRefHash, pgStatEntryRefHashContext, pgStatLocal, pgStatSharedRefAge, and PgStat_LocalState::shmem.

Referenced by pgstat_get_entry_ref().

◆ pgstat_unlock_entry()

void pgstat_unlock_entry ( PgStat_EntryRef * entry_ref )

Definition at line 603 of file pgstat_shmem.c.

 {
     LWLockRelease(&entry_ref->shared_stats->lock);
 }

References PgStatShared_Common::lock, LWLockRelease(), and PgStat_EntryRef::shared_stats.

Referenced by pgstat_copy_relation_stats(), pgstat_create_replslot(), pgstat_database_flush_cb(), pgstat_fetch_entry(), pgstat_function_flush_cb(), pgstat_relation_flush_cb(), pgstat_report_analyze(), pgstat_report_autovac(), pgstat_report_checksum_failures_in_db(), pgstat_report_replslot(), pgstat_report_vacuum(), pgstat_reset_database_timestamp(), pgstat_reset_entry(), and pgstat_subscription_flush_cb().

◆ shared_stat_reset_contents()

static void shared_stat_reset_contents	(	PgStat_Kind	kind,
		PgStatShared_Common *	header,
		TimestampTz	ts
	)

static

Definition at line 917 of file pgstat_shmem.c.

 {
     const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
  
     memset(pgstat_get_entry_data(kind, header), 0,
            pgstat_get_entry_len(kind));
  
     if (kind_info->reset_timestamp_cb)
         kind_info->reset_timestamp_cb(header, ts);
 }

References header(), pgstat_get_entry_data(), pgstat_get_entry_len(), pgstat_get_kind_info(), and PgStat_KindInfo::reset_timestamp_cb.

Referenced by pgstat_reset_entry(), and pgstat_reset_matching_entries().

◆ StatsShmemInit()

void StatsShmemInit ( void )

Definition at line 140 of file pgstat_shmem.c.

 {
     bool        found;
     Size        sz;
  
     sz = StatsShmemSize();
     pgStatLocal.shmem = (PgStat_ShmemControl *)
         ShmemInitStruct("Shared Memory Stats", sz, &found);
  
     if (!IsUnderPostmaster)
     {
         dsa_area   *dsa;
         dshash_table *dsh;
         PgStat_ShmemControl *ctl = pgStatLocal.shmem;
         char       *p = (char *) ctl;
  
         Assert(!found);
  
         /* the allocation of pgStatLocal.shmem itself */
         p += MAXALIGN(sizeof(PgStat_ShmemControl));
  
         /*
          * Create a small dsa allocation in plain shared memory. This is
          * required because postmaster cannot use dsm segments. It also
          * provides a small efficiency win.
          */
         ctl->raw_dsa_area = p;
         p += MAXALIGN(pgstat_dsa_init_size());
         dsa = dsa_create_in_place(ctl->raw_dsa_area,
                                   pgstat_dsa_init_size(),
                                   LWTRANCHE_PGSTATS_DSA, 0);
         dsa_pin(dsa);
  
         /*
          * To ensure dshash is created in "plain" shared memory, temporarily
          * limit size of dsa to the initial size of the dsa.
          */
         dsa_set_size_limit(dsa, pgstat_dsa_init_size());
  
         /*
          * With the limit in place, create the dshash table. XXX: It'd be nice
          * if there were dshash_create_in_place().
          */
         dsh = dshash_create(dsa, &dsh_params, 0);
         ctl->hash_handle = dshash_get_hash_table_handle(dsh);
  
         /* lift limit set above */
         dsa_set_size_limit(dsa, -1);
  
         /*
          * Postmaster will never access these again, thus free the local
          * dsa/dshash references.
          */
         dshash_detach(dsh);
         dsa_detach(dsa);
  
         pg_atomic_init_u64(&ctl->gc_request_count, 1);
  
  
         /* initialize fixed-numbered stats */
         LWLockInitialize(&ctl->archiver.lock, LWTRANCHE_PGSTATS_DATA);
         LWLockInitialize(&ctl->bgwriter.lock, LWTRANCHE_PGSTATS_DATA);
         LWLockInitialize(&ctl->checkpointer.lock, LWTRANCHE_PGSTATS_DATA);
         LWLockInitialize(&ctl->slru.lock, LWTRANCHE_PGSTATS_DATA);
         LWLockInitialize(&ctl->wal.lock, LWTRANCHE_PGSTATS_DATA);
  
         for (int i = 0; i < BACKEND_NUM_TYPES; i++)
             LWLockInitialize(&ctl->io.locks[i],
                              LWTRANCHE_PGSTATS_DATA);
     }
     else
     {
         Assert(found);
     }
 }

Referenced by CreateSharedMemoryAndSemaphores().

◆ StatsShmemSize()

Size StatsShmemSize ( void )

Definition at line 126 of file pgstat_shmem.c.

 {
     Size        sz;
  
     sz = MAXALIGN(sizeof(PgStat_ShmemControl));
     sz = add_size(sz, pgstat_dsa_init_size());
  
     return sz;
 }

References add_size(), MAXALIGN, and pgstat_dsa_init_size().

Referenced by CalculateShmemSize(), and StatsShmemInit().

Variable Documentation

◆ dsh_params

const dshash_parameters dsh_params

static

Initial value:

= {
    sizeof(PgStat_HashKey),
    sizeof(PgStatShared_HashEntry),
    pgstat_cmp_hash_key,
    pgstat_hash_hash_key,
    LWTRANCHE_PGSTATS_HASH
}

Definition at line 62 of file pgstat_shmem.c.

Referenced by pgstat_attach_shmem(), and StatsShmemInit().

◆ pgStatEntryRefHash

pgstat_entry_ref_hash_hash* pgStatEntryRefHash = NULL

static

Definition at line 81 of file pgstat_shmem.c.

Referenced by pgstat_drop_entry(), pgstat_drop_entry_internal(), pgstat_gc_entry_refs(), pgstat_get_entry_ref_cached(), pgstat_need_entry_refs_gc(), pgstat_release_all_entry_refs(), pgstat_release_entry_ref(), pgstat_release_matching_entry_refs(), and pgstat_setup_shared_refs().

◆ pgStatEntryRefHashContext

MemoryContext pgStatEntryRefHashContext = NULL

static

Definition at line 90 of file pgstat_shmem.c.

Referenced by pgstat_setup_memcxt(), and pgstat_setup_shared_refs().

◆ pgStatSharedRefAge

int pgStatSharedRefAge = 0

static

Definition at line 82 of file pgstat_shmem.c.

Referenced by pgstat_gc_entry_refs(), pgstat_need_entry_refs_gc(), and pgstat_setup_shared_refs().

◆ pgStatSharedRefContext

MemoryContext pgStatSharedRefContext = NULL

static

Definition at line 89 of file pgstat_shmem.c.

Referenced by pgstat_get_entry_ref_cached(), and pgstat_setup_memcxt().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ PGSTAT_ENTRY_REF_HASH_SIZE

◆ SH_DECLARE

◆ SH_DEFINE

◆ SH_ELEMENT_TYPE

◆ SH_EQUAL

◆ SH_HASH_KEY

◆ SH_KEY

◆ SH_KEY_TYPE

◆ SH_PREFIX

◆ SH_SCOPE

Typedef Documentation

◆ PgStat_EntryRefHashEntry

◆ ReleaseMatchCB

Function Documentation

◆ match_db()

◆ match_kind()

◆ pgstat_acquire_entry_ref()

◆ pgstat_attach_shmem()

◆ pgstat_detach_shmem()

◆ pgstat_drop_all_entries()

◆ pgstat_drop_database_and_contents()

◆ pgstat_drop_entry()

◆ pgstat_drop_entry_internal()

◆ pgstat_dsa_init_size()

◆ pgstat_free_entry()

◆ pgstat_gc_entry_refs()

◆ pgstat_get_entry_ref()

◆ pgstat_get_entry_ref_cached()

◆ pgstat_get_entry_ref_locked()

◆ pgstat_init_entry()

◆ pgstat_lock_entry()

◆ pgstat_lock_entry_shared()

◆ pgstat_need_entry_refs_gc()

◆ pgstat_reinit_entry()

◆ pgstat_release_all_entry_refs()

◆ pgstat_release_db_entry_refs()

◆ pgstat_release_entry_ref()

◆ pgstat_release_matching_entry_refs()

◆ pgstat_request_entry_refs_gc()

◆ pgstat_reset_entries_of_kind()

◆ pgstat_reset_entry()

◆ pgstat_reset_matching_entries()

◆ pgstat_setup_memcxt()

◆ pgstat_setup_shared_refs()

◆ pgstat_unlock_entry()

◆ shared_stat_reset_contents()

◆ StatsShmemInit()

◆ StatsShmemSize()

Variable Documentation

◆ dsh_params

◆ pgStatEntryRefHash

◆ pgStatEntryRefHashContext

◆ pgStatSharedRefAge

◆ pgStatSharedRefContext