pgstat.h File Reference

#include "datatype/timestamp.h"
#include "portability/instr_time.h"
#include "postmaster/pgarch.h"
#include "utils/backend_progress.h"
#include "utils/backend_status.h"
#include "utils/relcache.h"
#include "utils/wait_event.h"

Include dependency graph for pgstat.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	PgStat_FunctionCounts
struct	PgStat_FunctionCallUsage
struct	PgStat_BackendSubEntry
struct	PgStat_TableCounts
struct	PgStat_TableStatus
struct	PgStat_TableXactStatus
struct	PgStat_ArchiverStats
struct	PgStat_BgWriterStats
struct	PgStat_CheckpointerStats
struct	PgStat_BktypeIO
struct	PgStat_IO
struct	PgStat_StatDBEntry
struct	PgStat_StatFuncEntry
struct	PgStat_StatReplSlotEntry
struct	PgStat_SLRUStats
struct	PgStat_StatSubEntry
struct	PgStat_StatTabEntry
struct	PgStat_WalStats
struct	PgStat_PendingWalStats

Macros
#define	PGSTAT_STAT_PERMANENT_DIRECTORY   "pg_stat"
#define	PGSTAT_STAT_PERMANENT_FILENAME   "pg_stat/pgstat.stat"
#define	PGSTAT_STAT_PERMANENT_TMPFILE   "pg_stat/pgstat.tmp"
#define	PG_STAT_TMP_DIR   "pg_stat_tmp"
#define	PGSTAT_KIND_FIRST_VALID   PGSTAT_KIND_DATABASE
#define	PGSTAT_KIND_LAST   PGSTAT_KIND_WAL
#define	PGSTAT_NUM_KINDS   (PGSTAT_KIND_LAST + 1)
#define	PGSTAT_FILE_FORMAT_ID   0x01A5BCAB
#define	IOOBJECT_NUM_TYPES   (IOOBJECT_TEMP_RELATION + 1)
#define	IOCONTEXT_NUM_TYPES   (IOCONTEXT_VACUUM + 1)
#define	IOOP_NUM_TYPES   (IOOP_WRITE + 1)
#define	pgstat_count_buffer_read_time(n)    (pgStatBlockReadTime += (n))
#define	pgstat_count_buffer_write_time(n)    (pgStatBlockWriteTime += (n))
#define	pgstat_count_conn_active_time(n)    (pgStatActiveTime += (n))
#define	pgstat_count_conn_txn_idle_time(n)    (pgStatTransactionIdleTime += (n))
#define	pgstat_should_count_relation(rel)
#define	pgstat_count_heap_scan(rel)
#define	pgstat_count_heap_getnext(rel)
#define	pgstat_count_heap_fetch(rel)
#define	pgstat_count_index_scan(rel)
#define	pgstat_count_index_tuples(rel, n)
#define	pgstat_count_buffer_read(rel)
#define	pgstat_count_buffer_hit(rel)

Typedefs
typedef enum PgStat_Kind	PgStat_Kind
typedef enum TrackFunctionsLevel	TrackFunctionsLevel
typedef enum PgStat_FetchConsistency	PgStat_FetchConsistency
typedef enum SessionEndType	SessionEndType
typedef int64	PgStat_Counter
typedef struct PgStat_FunctionCounts	PgStat_FunctionCounts
typedef struct PgStat_FunctionCallUsage	PgStat_FunctionCallUsage
typedef struct PgStat_BackendSubEntry	PgStat_BackendSubEntry
typedef struct PgStat_TableCounts	PgStat_TableCounts
typedef struct PgStat_TableStatus	PgStat_TableStatus
typedef struct PgStat_TableXactStatus	PgStat_TableXactStatus
typedef struct PgStat_ArchiverStats	PgStat_ArchiverStats
typedef struct PgStat_BgWriterStats	PgStat_BgWriterStats
typedef struct PgStat_CheckpointerStats	PgStat_CheckpointerStats
typedef enum IOObject	IOObject
typedef enum IOContext	IOContext
typedef enum IOOp	IOOp
typedef struct PgStat_BktypeIO	PgStat_BktypeIO
typedef struct PgStat_IO	PgStat_IO
typedef struct PgStat_StatDBEntry	PgStat_StatDBEntry
typedef struct PgStat_StatFuncEntry	PgStat_StatFuncEntry
typedef struct PgStat_StatReplSlotEntry	PgStat_StatReplSlotEntry
typedef struct PgStat_SLRUStats	PgStat_SLRUStats
typedef struct PgStat_StatSubEntry	PgStat_StatSubEntry
typedef struct PgStat_StatTabEntry	PgStat_StatTabEntry
typedef struct PgStat_WalStats	PgStat_WalStats
typedef struct PgStat_PendingWalStats	PgStat_PendingWalStats

Enumerations
enum	PgStat_Kind {   PGSTAT_KIND_INVALID = 0 , PGSTAT_KIND_DATABASE , PGSTAT_KIND_RELATION , PGSTAT_KIND_FUNCTION ,   PGSTAT_KIND_REPLSLOT , PGSTAT_KIND_SUBSCRIPTION , PGSTAT_KIND_ARCHIVER , PGSTAT_KIND_BGWRITER ,   PGSTAT_KIND_CHECKPOINTER , PGSTAT_KIND_IO , PGSTAT_KIND_SLRU , PGSTAT_KIND_WAL }
enum	TrackFunctionsLevel { TRACK_FUNC_OFF , TRACK_FUNC_PL , TRACK_FUNC_ALL }
enum	PgStat_FetchConsistency { PGSTAT_FETCH_CONSISTENCY_NONE , PGSTAT_FETCH_CONSISTENCY_CACHE , PGSTAT_FETCH_CONSISTENCY_SNAPSHOT }
enum	SessionEndType {   DISCONNECT_NOT_YET , DISCONNECT_NORMAL , DISCONNECT_CLIENT_EOF , DISCONNECT_FATAL ,   DISCONNECT_KILLED }
enum	IOObject { IOOBJECT_RELATION , IOOBJECT_TEMP_RELATION }
enum	IOContext { IOCONTEXT_BULKREAD , IOCONTEXT_BULKWRITE , IOCONTEXT_NORMAL , IOCONTEXT_VACUUM }
enum	IOOp {   IOOP_EVICT , IOOP_EXTEND , IOOP_FSYNC , IOOP_HIT ,   IOOP_READ , IOOP_REUSE , IOOP_WRITE }

Functions
Size	StatsShmemSize (void)
void	StatsShmemInit (void)
void	pgstat_restore_stats (void)
void	pgstat_discard_stats (void)
void	pgstat_before_server_shutdown (int code, Datum arg)
void	pgstat_initialize (void)
long	pgstat_report_stat (bool force)
void	pgstat_force_next_flush (void)
void	pgstat_reset_counters (void)
void	pgstat_reset (PgStat_Kind kind, Oid dboid, Oid objoid)
void	pgstat_reset_of_kind (PgStat_Kind kind)
void	pgstat_clear_snapshot (void)
TimestampTz	pgstat_get_stat_snapshot_timestamp (bool *have_snapshot)
PgStat_Kind	pgstat_get_kind_from_str (char *kind_str)
bool	pgstat_have_entry (PgStat_Kind kind, Oid dboid, Oid objoid)
void	pgstat_report_archiver (const char *xlog, bool failed)
PgStat_ArchiverStats *	pgstat_fetch_stat_archiver (void)
void	pgstat_report_bgwriter (void)
PgStat_BgWriterStats *	pgstat_fetch_stat_bgwriter (void)
void	pgstat_report_checkpointer (void)
PgStat_CheckpointerStats *	pgstat_fetch_stat_checkpointer (void)
bool	pgstat_bktype_io_stats_valid (PgStat_BktypeIO *context_ops, BackendType bktype)
void	pgstat_count_io_op (IOObject io_object, IOContext io_context, IOOp io_op)
PgStat_IO *	pgstat_fetch_stat_io (void)
const char *	pgstat_get_io_context_name (IOContext io_context)
const char *	pgstat_get_io_object_name (IOObject io_object)
bool	pgstat_tracks_io_bktype (BackendType bktype)
bool	pgstat_tracks_io_object (BackendType bktype, IOObject io_object, IOContext io_context)
bool	pgstat_tracks_io_op (BackendType bktype, IOObject io_object, IOContext io_context, IOOp io_op)
void	pgstat_drop_database (Oid databaseid)
void	pgstat_report_autovac (Oid dboid)
void	pgstat_report_recovery_conflict (int reason)
void	pgstat_report_deadlock (void)
void	pgstat_report_checksum_failures_in_db (Oid dboid, int failurecount)
void	pgstat_report_checksum_failure (void)
void	pgstat_report_connect (Oid dboid)
PgStat_StatDBEntry *	pgstat_fetch_stat_dbentry (Oid dboid)
void	pgstat_create_function (Oid proid)
void	pgstat_drop_function (Oid proid)
void	pgstat_init_function_usage (struct FunctionCallInfoBaseData *fcinfo, PgStat_FunctionCallUsage *fcu)
void	pgstat_end_function_usage (PgStat_FunctionCallUsage *fcu, bool finalize)
PgStat_StatFuncEntry *	pgstat_fetch_stat_funcentry (Oid func_id)
PgStat_FunctionCounts *	find_funcstat_entry (Oid func_id)
void	pgstat_create_relation (Relation rel)
void	pgstat_drop_relation (Relation rel)
void	pgstat_copy_relation_stats (Relation dst, Relation src)
void	pgstat_init_relation (Relation rel)
void	pgstat_assoc_relation (Relation rel)
void	pgstat_unlink_relation (Relation rel)
void	pgstat_report_vacuum (Oid tableoid, bool shared, PgStat_Counter livetuples, PgStat_Counter deadtuples)
void	pgstat_report_analyze (Relation rel, PgStat_Counter livetuples, PgStat_Counter deadtuples, bool resetcounter)
void	pgstat_count_heap_insert (Relation rel, PgStat_Counter n)
void	pgstat_count_heap_update (Relation rel, bool hot, bool newpage)
void	pgstat_count_heap_delete (Relation rel)
void	pgstat_count_truncate (Relation rel)
void	pgstat_update_heap_dead_tuples (Relation rel, int delta)
void	pgstat_twophase_postcommit (TransactionId xid, uint16 info, void *recdata, uint32 len)
void	pgstat_twophase_postabort (TransactionId xid, uint16 info, void *recdata, uint32 len)
PgStat_StatTabEntry *	pgstat_fetch_stat_tabentry (Oid relid)
PgStat_StatTabEntry *	pgstat_fetch_stat_tabentry_ext (bool shared, Oid reloid)
PgStat_TableStatus *	find_tabstat_entry (Oid rel_id)
void	pgstat_reset_replslot (const char *name)
void	pgstat_report_replslot (struct ReplicationSlot *slot, const PgStat_StatReplSlotEntry *repSlotStat)
void	pgstat_create_replslot (struct ReplicationSlot *slot)
void	pgstat_acquire_replslot (struct ReplicationSlot *slot)
void	pgstat_drop_replslot (struct ReplicationSlot *slot)
PgStat_StatReplSlotEntry *	pgstat_fetch_replslot (NameData slotname)
void	pgstat_reset_slru (const char *)
void	pgstat_count_slru_page_zeroed (int slru_idx)
void	pgstat_count_slru_page_hit (int slru_idx)
void	pgstat_count_slru_page_read (int slru_idx)
void	pgstat_count_slru_page_written (int slru_idx)
void	pgstat_count_slru_page_exists (int slru_idx)
void	pgstat_count_slru_flush (int slru_idx)
void	pgstat_count_slru_truncate (int slru_idx)
const char *	pgstat_get_slru_name (int slru_idx)
int	pgstat_get_slru_index (const char *name)
PgStat_SLRUStats *	pgstat_fetch_slru (void)
void	pgstat_report_subscription_error (Oid subid, bool is_apply_error)
void	pgstat_create_subscription (Oid subid)
void	pgstat_drop_subscription (Oid subid)
PgStat_StatSubEntry *	pgstat_fetch_stat_subscription (Oid subid)
void	AtEOXact_PgStat (bool isCommit, bool parallel)
void	AtEOSubXact_PgStat (bool isCommit, int nestDepth)
void	AtPrepare_PgStat (void)
void	PostPrepare_PgStat (void)
int	pgstat_get_transactional_drops (bool isCommit, struct xl_xact_stats_item **items)
void	pgstat_execute_transactional_drops (int ndrops, struct xl_xact_stats_item *items, bool is_redo)
void	pgstat_report_wal (bool force)
PgStat_WalStats *	pgstat_fetch_stat_wal (void)

Variables
PGDLLIMPORT bool	pgstat_track_counts
PGDLLIMPORT int	pgstat_track_functions
PGDLLIMPORT int	pgstat_fetch_consistency
PGDLLIMPORT PgStat_BgWriterStats	PendingBgWriterStats
PGDLLIMPORT PgStat_CheckpointerStats	PendingCheckpointerStats
PGDLLIMPORT PgStat_Counter	pgStatBlockReadTime
PGDLLIMPORT PgStat_Counter	pgStatBlockWriteTime
PGDLLIMPORT PgStat_Counter	pgStatActiveTime
PGDLLIMPORT PgStat_Counter	pgStatTransactionIdleTime
PGDLLIMPORT SessionEndType	pgStatSessionEndCause
PGDLLIMPORT PgStat_PendingWalStats	PendingWalStats

Macro Definition Documentation

IOCONTEXT_NUM_TYPES

#define IOCONTEXT_NUM_TYPES   (IOCONTEXT_VACUUM + 1)

Definition at line 292 of file pgstat.h.

IOOBJECT_NUM_TYPES

#define IOOBJECT_NUM_TYPES   (IOOBJECT_TEMP_RELATION + 1)

Definition at line 282 of file pgstat.h.

IOOP_NUM_TYPES

#define IOOP_NUM_TYPES   (IOOP_WRITE + 1)

Definition at line 305 of file pgstat.h.

PG_STAT_TMP_DIR

#define PG_STAT_TMP_DIR   "pg_stat_tmp"

Definition at line 32 of file pgstat.h.

pgstat_count_buffer_hit

#define pgstat_count_buffer_hit

(

rel

)

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.blocks_hit++;                \
    } while (0)

Definition at line 630 of file pgstat.h.

pgstat_count_buffer_read

#define pgstat_count_buffer_read

(

rel

)

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.blocks_fetched++;            \
    } while (0)

Definition at line 625 of file pgstat.h.

pgstat_count_buffer_read_time

#define pgstat_count_buffer_read_time

(

n

)

(pgStatBlockReadTime += (n))

Definition at line 542 of file pgstat.h.

pgstat_count_buffer_write_time

#define pgstat_count_buffer_write_time

(

n

)

(pgStatBlockWriteTime += (n))

Definition at line 544 of file pgstat.h.

pgstat_count_conn_active_time

#define pgstat_count_conn_active_time

(

n

)

(pgStatActiveTime += (n))

Definition at line 546 of file pgstat.h.

pgstat_count_conn_txn_idle_time

#define pgstat_count_conn_txn_idle_time

(

n

)

(pgStatTransactionIdleTime += (n))

Definition at line 548 of file pgstat.h.

pgstat_count_heap_fetch

#define pgstat_count_heap_fetch

(

rel

)

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.tuples_fetched++;            \
    } while (0)

Definition at line 610 of file pgstat.h.

pgstat_count_heap_getnext

#define pgstat_count_heap_getnext

(

rel

)

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.tuples_returned++;           \
    } while (0)

Definition at line 605 of file pgstat.h.

pgstat_count_heap_scan

#define pgstat_count_heap_scan

(

rel

)

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.numscans++;                  \
    } while (0)

Definition at line 600 of file pgstat.h.

pgstat_count_index_scan

#define pgstat_count_index_scan

(

rel

)

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.numscans++;                  \
    } while (0)

Definition at line 615 of file pgstat.h.

pgstat_count_index_tuples

#define pgstat_count_index_tuples	(		rel,
			n
	)

Value:

    do {                                                            \
        if (pgstat_should_count_relation(rel))                      \
            (rel)->pgstat_info->counts.tuples_returned += (n);      \
    } while (0)

Definition at line 620 of file pgstat.h.

PGSTAT_FILE_FORMAT_ID

#define PGSTAT_FILE_FORMAT_ID   0x01A5BCAB

Definition at line 238 of file pgstat.h.

PGSTAT_KIND_FIRST_VALID

#define PGSTAT_KIND_FIRST_VALID   PGSTAT_KIND_DATABASE

Definition at line 56 of file pgstat.h.

PGSTAT_KIND_LAST

#define PGSTAT_KIND_LAST   PGSTAT_KIND_WAL

Definition at line 57 of file pgstat.h.

PGSTAT_NUM_KINDS

#define PGSTAT_NUM_KINDS   (PGSTAT_KIND_LAST + 1)

Definition at line 58 of file pgstat.h.

pgstat_should_count_relation

#define pgstat_should_count_relation

(

rel

)

Value:

    (likely((rel)->pgstat_info != NULL) ? true :                    \
     ((rel)->pgstat_enabled ? pgstat_assoc_relation(rel), true : false))

Definition at line 594 of file pgstat.h.

PGSTAT_STAT_PERMANENT_DIRECTORY

#define PGSTAT_STAT_PERMANENT_DIRECTORY   "pg_stat"

Definition at line 27 of file pgstat.h.

PGSTAT_STAT_PERMANENT_FILENAME

#define PGSTAT_STAT_PERMANENT_FILENAME   "pg_stat/pgstat.stat"

Definition at line 28 of file pgstat.h.

PGSTAT_STAT_PERMANENT_TMPFILE

#define PGSTAT_STAT_PERMANENT_TMPFILE   "pg_stat/pgstat.tmp"

Definition at line 29 of file pgstat.h.

Typedef Documentation

IOContext

typedef enum IOContext IOContext

IOObject

typedef enum IOObject IOObject

IOOp

typedef enum IOOp IOOp

PgStat_ArchiverStats

typedef struct PgStat_ArchiverStats PgStat_ArchiverStats

PgStat_BackendSubEntry

typedef struct PgStat_BackendSubEntry PgStat_BackendSubEntry

PgStat_BgWriterStats

typedef struct PgStat_BgWriterStats PgStat_BgWriterStats

PgStat_BktypeIO

typedef struct PgStat_BktypeIO PgStat_BktypeIO

PgStat_CheckpointerStats

typedef struct PgStat_CheckpointerStats PgStat_CheckpointerStats

PgStat_Counter

typedef int64 PgStat_Counter

Definition at line 89 of file pgstat.h.

PgStat_FetchConsistency

typedef enum PgStat_FetchConsistency PgStat_FetchConsistency

PgStat_FunctionCallUsage

typedef struct PgStat_FunctionCallUsage PgStat_FunctionCallUsage

PgStat_FunctionCounts

typedef struct PgStat_FunctionCounts PgStat_FunctionCounts

PgStat_IO

typedef struct PgStat_IO PgStat_IO

PgStat_Kind

typedef enum PgStat_Kind PgStat_Kind

PgStat_PendingWalStats

typedef struct PgStat_PendingWalStats PgStat_PendingWalStats

PgStat_SLRUStats

typedef struct PgStat_SLRUStats PgStat_SLRUStats

PgStat_StatDBEntry

typedef struct PgStat_StatDBEntry PgStat_StatDBEntry

PgStat_StatFuncEntry

typedef struct PgStat_StatFuncEntry PgStat_StatFuncEntry

PgStat_StatReplSlotEntry

typedef struct PgStat_StatReplSlotEntry PgStat_StatReplSlotEntry

PgStat_StatSubEntry

typedef struct PgStat_StatSubEntry PgStat_StatSubEntry

PgStat_StatTabEntry

typedef struct PgStat_StatTabEntry PgStat_StatTabEntry

PgStat_TableCounts

typedef struct PgStat_TableCounts PgStat_TableCounts

PgStat_TableStatus

typedef struct PgStat_TableStatus PgStat_TableStatus

PgStat_TableXactStatus

typedef struct PgStat_TableXactStatus PgStat_TableXactStatus

PgStat_WalStats

typedef struct PgStat_WalStats PgStat_WalStats

SessionEndType

typedef enum SessionEndType SessionEndType

TrackFunctionsLevel

typedef enum TrackFunctionsLevel TrackFunctionsLevel

Enumeration Type Documentation

IOContext

enum IOContext

Enumerator
IOCONTEXT_BULKREAD
IOCONTEXT_BULKWRITE
IOCONTEXT_NORMAL
IOCONTEXT_VACUUM

Definition at line 284 of file pgstat.h.

{
    IOCONTEXT_BULKREAD,
    IOCONTEXT_BULKWRITE,
    IOCONTEXT_NORMAL,
    IOCONTEXT_VACUUM,
} IOContext;

IOObject

enum IOObject

Enumerator
IOOBJECT_RELATION
IOOBJECT_TEMP_RELATION

Definition at line 276 of file pgstat.h.

{
    IOOBJECT_RELATION,
    IOOBJECT_TEMP_RELATION,
} IOObject;

IOOp

enum IOOp

Enumerator
IOOP_EVICT
IOOP_EXTEND
IOOP_FSYNC
IOOP_HIT
IOOP_READ
IOOP_REUSE
IOOP_WRITE

Definition at line 294 of file pgstat.h.

{
    IOOP_EVICT,
    IOOP_EXTEND,
    IOOP_FSYNC,
    IOOP_HIT,
    IOOP_READ,
    IOOP_REUSE,
    IOOP_WRITE,
} IOOp;

PgStat_FetchConsistency

enum PgStat_FetchConsistency

Enumerator
PGSTAT_FETCH_CONSISTENCY_NONE
PGSTAT_FETCH_CONSISTENCY_CACHE
PGSTAT_FETCH_CONSISTENCY_SNAPSHOT

Definition at line 68 of file pgstat.h.

{
    PGSTAT_FETCH_CONSISTENCY_NONE,
    PGSTAT_FETCH_CONSISTENCY_CACHE,
    PGSTAT_FETCH_CONSISTENCY_SNAPSHOT,
} PgStat_FetchConsistency;

PgStat_Kind

enum PgStat_Kind

Enumerator
PGSTAT_KIND_INVALID
PGSTAT_KIND_DATABASE
PGSTAT_KIND_RELATION
PGSTAT_KIND_FUNCTION
PGSTAT_KIND_REPLSLOT
PGSTAT_KIND_SUBSCRIPTION
PGSTAT_KIND_ARCHIVER
PGSTAT_KIND_BGWRITER
PGSTAT_KIND_CHECKPOINTER
PGSTAT_KIND_IO
PGSTAT_KIND_SLRU
PGSTAT_KIND_WAL

Definition at line 35 of file pgstat.h.

{
    /* use 0 for INVALID, to catch zero-initialized data */
    PGSTAT_KIND_INVALID = 0,
 
    /* stats for variable-numbered objects */
    PGSTAT_KIND_DATABASE,       /* database-wide statistics */
    PGSTAT_KIND_RELATION,       /* per-table statistics */
    PGSTAT_KIND_FUNCTION,       /* per-function statistics */
    PGSTAT_KIND_REPLSLOT,       /* per-slot statistics */
    PGSTAT_KIND_SUBSCRIPTION,   /* per-subscription statistics */
 
    /* stats for fixed-numbered objects */
    PGSTAT_KIND_ARCHIVER,
    PGSTAT_KIND_BGWRITER,
    PGSTAT_KIND_CHECKPOINTER,
    PGSTAT_KIND_IO,
    PGSTAT_KIND_SLRU,
    PGSTAT_KIND_WAL,
} PgStat_Kind;

SessionEndType

enum SessionEndType

Enumerator
DISCONNECT_NOT_YET
DISCONNECT_NORMAL
DISCONNECT_CLIENT_EOF
DISCONNECT_FATAL
DISCONNECT_KILLED

Definition at line 76 of file pgstat.h.

{
    DISCONNECT_NOT_YET,         /* still active */
    DISCONNECT_NORMAL,
    DISCONNECT_CLIENT_EOF,
    DISCONNECT_FATAL,
    DISCONNECT_KILLED
} SessionEndType;

TrackFunctionsLevel

enum TrackFunctionsLevel

Enumerator
TRACK_FUNC_OFF
TRACK_FUNC_PL
TRACK_FUNC_ALL

Definition at line 61 of file pgstat.h.

{
    TRACK_FUNC_OFF,
    TRACK_FUNC_PL,
    TRACK_FUNC_ALL
}           TrackFunctionsLevel;

Function Documentation

AtEOSubXact_PgStat()

void AtEOSubXact_PgStat	(	bool	isCommit,
		int	nestDepth
	)

Definition at line 113 of file pgstat_xact.c.

{
    PgStat_SubXactStatus *xact_state;
 
    /* merge the sub-transaction's transactional stats into the parent */
    xact_state = pgStatXactStack;
    if (xact_state != NULL &&
        xact_state->nest_level >= nestDepth)
    {
        /* delink xact_state from stack immediately to simplify reuse case */
        pgStatXactStack = xact_state->prev;
 
        AtEOSubXact_PgStat_Relations(xact_state, isCommit, nestDepth);
        AtEOSubXact_PgStat_DroppedStats(xact_state, isCommit, nestDepth);
 
        pfree(xact_state);
    }
}

References AtEOSubXact_PgStat_DroppedStats(), AtEOSubXact_PgStat_Relations(), PgStat_SubXactStatus::nest_level, pfree(), pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_PgStat()

void AtEOXact_PgStat	(	bool	isCommit,
		bool	parallel
	)

Definition at line 41 of file pgstat_xact.c.

{
    PgStat_SubXactStatus *xact_state;
 
    AtEOXact_PgStat_Database(isCommit, parallel);
 
    /* handle transactional stats information */
    xact_state = pgStatXactStack;
    if (xact_state != NULL)
    {
        Assert(xact_state->nest_level == 1);
        Assert(xact_state->prev == NULL);
 
        AtEOXact_PgStat_Relations(xact_state, isCommit);
        AtEOXact_PgStat_DroppedStats(xact_state, isCommit);
    }
    pgStatXactStack = NULL;
 
    /* Make sure any stats snapshot is thrown away */
    pgstat_clear_snapshot();
}

References Assert(), AtEOXact_PgStat_Database(), AtEOXact_PgStat_DroppedStats(), AtEOXact_PgStat_Relations(), PgStat_SubXactStatus::nest_level, pgstat_clear_snapshot(), pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by AbortTransaction(), CommitTransaction(), and FinishPreparedTransaction().

AtPrepare_PgStat()

void AtPrepare_PgStat

(

void

)

Definition at line 190 of file pgstat_xact.c.

{
    PgStat_SubXactStatus *xact_state;
 
    xact_state = pgStatXactStack;
    if (xact_state != NULL)
    {
        Assert(xact_state->nest_level == 1);
        Assert(xact_state->prev == NULL);
 
        AtPrepare_PgStat_Relations(xact_state);
    }
}

References Assert(), AtPrepare_PgStat_Relations(), PgStat_SubXactStatus::nest_level, pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by PrepareTransaction().

find_funcstat_entry()

PgStat_FunctionCounts* find_funcstat_entry

(

Oid

func_id

)

Definition at line 223 of file pgstat_function.c.

{
    PgStat_EntryRef *entry_ref;
 
    entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_FUNCTION, MyDatabaseId, func_id);
 
    if (entry_ref)
        return entry_ref->pending;
    return NULL;
}

References MyDatabaseId, PgStat_EntryRef::pending, pgstat_fetch_pending_entry(), and PGSTAT_KIND_FUNCTION.

Referenced by pg_stat_get_xact_function_calls().

find_tabstat_entry()

PgStat_TableStatus* find_tabstat_entry

(

Oid

rel_id

)

Definition at line 484 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
 
    entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION, MyDatabaseId, rel_id);
    if (!entry_ref)
        entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION, InvalidOid, rel_id);
 
    if (entry_ref)
        return entry_ref->pending;
    return NULL;
}

References InvalidOid, MyDatabaseId, PgStat_EntryRef::pending, pgstat_fetch_pending_entry(), and PGSTAT_KIND_RELATION.

Referenced by pg_stat_get_xact_tuples_deleted(), pg_stat_get_xact_tuples_inserted(), and pg_stat_get_xact_tuples_updated().

pgstat_acquire_replslot()

void pgstat_acquire_replslot

(

struct ReplicationSlot *

slot

)

Definition at line 144 of file pgstat_replslot.c.

{
    pgstat_get_entry_ref(PGSTAT_KIND_REPLSLOT, InvalidOid,
                         ReplicationSlotIndex(slot), true, NULL);
}

References InvalidOid, pgstat_get_entry_ref(), PGSTAT_KIND_REPLSLOT, and ReplicationSlotIndex().

Referenced by ReplicationSlotAcquire().

pgstat_assoc_relation()

void pgstat_assoc_relation

(

Relation

rel

)

Definition at line 133 of file pgstat_relation.c.

{
    Assert(rel->pgstat_enabled);
    Assert(rel->pgstat_info == NULL);
 
    /* Else find or make the PgStat_TableStatus entry, and update link */
    rel->pgstat_info = pgstat_prep_relation_pending(RelationGetRelid(rel),
                                                    rel->rd_rel->relisshared);
 
    /* don't allow link a stats to multiple relcache entries */
    Assert(rel->pgstat_info->relation == NULL);
 
    /* mark this relation as the owner */
    rel->pgstat_info->relation = rel;
}

References Assert(), RelationData::pgstat_enabled, RelationData::pgstat_info, pgstat_prep_relation_pending(), RelationData::rd_rel, PgStat_TableStatus::relation, and RelationGetRelid.

pgstat_before_server_shutdown()

void pgstat_before_server_shutdown	(	int	code,
		Datum	arg
	)

Definition at line 458 of file pgstat.c.

{
    Assert(pgStatLocal.shmem != NULL);
    Assert(!pgStatLocal.shmem->is_shutdown);
 
    /*
     * Stats should only be reported after pgstat_initialize() and before
     * pgstat_shutdown(). This is a convenient point to catch most violations
     * of this rule.
     */
    Assert(pgstat_is_initialized && !pgstat_is_shutdown);
 
    /* flush out our own pending changes before writing out */
    pgstat_report_stat(true);
 
    /*
     * Only write out file during normal shutdown. Don't even signal that
     * we've shutdown during irregular shutdowns, because the shutdown
     * sequence isn't coordinated to ensure this backend shuts down last.
     */
    if (code == 0)
    {
        pgStatLocal.shmem->is_shutdown = true;
        pgstat_write_statsfile();
    }
}

References Assert(), PgStat_ShmemControl::is_shutdown, pgstat_report_stat(), pgstat_write_statsfile(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by CheckpointerMain(), and InitPostgres().

pgstat_bktype_io_stats_valid()

bool pgstat_bktype_io_stats_valid	(	PgStat_BktypeIO *	context_ops,
		BackendType	bktype
	)

Definition at line 34 of file pgstat_io.c.

{
    bool        bktype_tracked = pgstat_tracks_io_bktype(bktype);
 
    for (int io_object = 0; io_object < IOOBJECT_NUM_TYPES; io_object++)
    {
        for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++)
        {
            /*
             * Don't bother trying to skip to the next loop iteration if
             * pgstat_tracks_io_object() would return false here. We still
             * need to validate that each counter is zero anyway.
             */
            for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++)
            {
                /* No stats, so nothing to validate */
                if (backend_io->data[io_object][io_context][io_op] == 0)
                    continue;
 
                /* There are stats and there shouldn't be */
                if (!bktype_tracked ||
                    !pgstat_tracks_io_op(bktype, io_object, io_context, io_op))
                    return false;
            }
        }
    }
 
    return true;
}

References PgStat_BktypeIO::data, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, pgstat_tracks_io_bktype(), and pgstat_tracks_io_op().

Referenced by pg_stat_get_io(), and pgstat_flush_io().

pgstat_clear_snapshot()

void pgstat_clear_snapshot

(

void

)

Definition at line 766 of file pgstat.c.

{
    pgstat_assert_is_up();
 
    memset(&pgStatLocal.snapshot.fixed_valid, 0,
           sizeof(pgStatLocal.snapshot.fixed_valid));
    pgStatLocal.snapshot.stats = NULL;
    pgStatLocal.snapshot.mode = PGSTAT_FETCH_CONSISTENCY_NONE;
 
    /* Release memory, if any was allocated */
    if (pgStatLocal.snapshot.context)
    {
        MemoryContextDelete(pgStatLocal.snapshot.context);
 
        /* Reset variables */
        pgStatLocal.snapshot.context = NULL;
    }
 
    /*
     * Historically the backend_status.c facilities lived in this file, and
     * were reset with the same function. For now keep it that way, and
     * forward the reset request.
     */
    pgstat_clear_backend_activity_snapshot();
}

References PgStat_Snapshot::context, PgStat_Snapshot::fixed_valid, MemoryContextDelete(), PgStat_Snapshot::mode, pgstat_assert_is_up, pgstat_clear_backend_activity_snapshot(), PGSTAT_FETCH_CONSISTENCY_NONE, pgStatLocal, PgStat_LocalState::snapshot, and PgStat_Snapshot::stats.

Referenced by AtEOXact_PgStat(), pg_stat_clear_snapshot(), and PostPrepare_PgStat().

pgstat_copy_relation_stats()

void pgstat_copy_relation_stats	(	Relation	dst,
		Relation	src
	)

Definition at line 59 of file pgstat_relation.c.

{
    PgStat_StatTabEntry *srcstats;
    PgStatShared_Relation *dstshstats;
    PgStat_EntryRef *dst_ref;
 
    srcstats = pgstat_fetch_stat_tabentry_ext(src->rd_rel->relisshared,
                                              RelationGetRelid(src));
    if (!srcstats)
        return;
 
    dst_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION,
                                          dst->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
                                          RelationGetRelid(dst),
                                          false);
 
    dstshstats = (PgStatShared_Relation *) dst_ref->shared_stats;
    dstshstats->stats = *srcstats;
 
    pgstat_unlock_entry(dst_ref);
}

References InvalidOid, MyDatabaseId, pgstat_fetch_stat_tabentry_ext(), pgstat_get_entry_ref_locked(), PGSTAT_KIND_RELATION, pgstat_unlock_entry(), RelationData::rd_rel, RelationGetRelid, PgStat_EntryRef::shared_stats, and PgStatShared_Relation::stats.

Referenced by index_concurrently_swap().

pgstat_count_heap_delete()

void pgstat_count_heap_delete

(

Relation

rel

)

Definition at line 402 of file pgstat_relation.c.

{
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        ensure_tabstat_xact_level(pgstat_info);
        pgstat_info->trans->tuples_deleted++;
    }
}

References ensure_tabstat_xact_level(), RelationData::pgstat_info, pgstat_should_count_relation, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_deleted.

Referenced by heap_abort_speculative(), and heap_delete().

pgstat_count_heap_insert()

void pgstat_count_heap_insert	(	Relation	rel,
		PgStat_Counter	n
	)

Definition at line 361 of file pgstat_relation.c.

{
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        ensure_tabstat_xact_level(pgstat_info);
        pgstat_info->trans->tuples_inserted += n;
    }
}

References ensure_tabstat_xact_level(), RelationData::pgstat_info, pgstat_should_count_relation, PgStat_TableStatus::trans, and PgStat_TableXactStatus::tuples_inserted.

Referenced by ExecRefreshMatView(), heap_insert(), and heap_multi_insert().

pgstat_count_heap_update()

void pgstat_count_heap_update	(	Relation	rel,
		bool	hot,
		bool	newpage
	)

Definition at line 376 of file pgstat_relation.c.

{
    Assert(!(hot && newpage));
 
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        ensure_tabstat_xact_level(pgstat_info);
        pgstat_info->trans->tuples_updated++;
 
        /*
         * tuples_hot_updated and tuples_newpage_updated counters are
         * nontransactional, so just advance them
         */
        if (hot)
            pgstat_info->counts.tuples_hot_updated++;
        else if (newpage)
            pgstat_info->counts.tuples_newpage_updated++;
    }
}

References Assert(), PgStat_TableStatus::counts, ensure_tabstat_xact_level(), RelationData::pgstat_info, pgstat_should_count_relation, PgStat_TableStatus::trans, PgStat_TableCounts::tuples_hot_updated, PgStat_TableCounts::tuples_newpage_updated, and PgStat_TableXactStatus::tuples_updated.

Referenced by heap_update().

pgstat_count_io_op()

void pgstat_count_io_op	(	IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op
	)

Definition at line 66 of file pgstat_io.c.

{
    Assert((unsigned int) io_object < IOOBJECT_NUM_TYPES);
    Assert((unsigned int) io_context < IOCONTEXT_NUM_TYPES);
    Assert((unsigned int) io_op < IOOP_NUM_TYPES);
    Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
 
    PendingIOStats.data[io_object][io_context][io_op]++;
 
    have_iostats = true;
}

References Assert(), PgStat_BktypeIO::data, have_iostats, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, MyBackendType, PendingIOStats, and pgstat_tracks_io_op().

Referenced by BufferAlloc(), FlushBuffer(), FlushRelationBuffers(), LocalBufferAlloc(), mdsyncfiletag(), ReadBuffer_common(), and register_dirty_segment().

pgstat_count_slru_flush()

void pgstat_count_slru_flush

(

int

slru_idx

)

Definition at line 89 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->flush += 1;
}

References PgStat_SLRUStats::flush, and get_slru_entry().

Referenced by SimpleLruWriteAll().

pgstat_count_slru_page_exists()

void pgstat_count_slru_page_exists

(

int

slru_idx

)

Definition at line 71 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->blocks_exists += 1;
}

References PgStat_SLRUStats::blocks_exists, and get_slru_entry().

Referenced by SimpleLruDoesPhysicalPageExist().

pgstat_count_slru_page_hit()

void pgstat_count_slru_page_hit

(

int

slru_idx

)

Definition at line 65 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->blocks_hit += 1;
}

References PgStat_SLRUStats::blocks_hit, and get_slru_entry().

Referenced by SimpleLruReadPage(), and SimpleLruReadPage_ReadOnly().

pgstat_count_slru_page_read()

void pgstat_count_slru_page_read

(

int

slru_idx

)

Definition at line 77 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->blocks_read += 1;
}

References PgStat_SLRUStats::blocks_read, and get_slru_entry().

Referenced by SimpleLruReadPage().

pgstat_count_slru_page_written()

void pgstat_count_slru_page_written

(

int

slru_idx

)

Definition at line 83 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->blocks_written += 1;
}

References PgStat_SLRUStats::blocks_written, and get_slru_entry().

Referenced by SlruPhysicalWritePage().

pgstat_count_slru_page_zeroed()

void pgstat_count_slru_page_zeroed

(

int

slru_idx

)

Definition at line 59 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->blocks_zeroed += 1;
}

References PgStat_SLRUStats::blocks_zeroed, and get_slru_entry().

Referenced by SimpleLruZeroPage().

pgstat_count_slru_truncate()

void pgstat_count_slru_truncate

(

int

slru_idx

)

Definition at line 95 of file pgstat_slru.c.

{
    get_slru_entry(slru_idx)->truncate += 1;
}

References get_slru_entry(), and PgStat_SLRUStats::truncate.

Referenced by SimpleLruTruncate().

pgstat_count_truncate()

void pgstat_count_truncate

(

Relation

rel

)

Definition at line 417 of file pgstat_relation.c.

{
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        ensure_tabstat_xact_level(pgstat_info);
        save_truncdrop_counters(pgstat_info->trans, false);
        pgstat_info->trans->tuples_inserted = 0;
        pgstat_info->trans->tuples_updated = 0;
        pgstat_info->trans->tuples_deleted = 0;
    }
}

References ensure_tabstat_xact_level(), RelationData::pgstat_info, pgstat_should_count_relation, save_truncdrop_counters(), PgStat_TableStatus::trans, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, and PgStat_TableXactStatus::tuples_updated.

Referenced by ExecRefreshMatView(), and ExecuteTruncateGuts().

pgstat_create_function()

void pgstat_create_function

(

Oid

proid

)

Definition at line 45 of file pgstat_function.c.

{
    pgstat_create_transactional(PGSTAT_KIND_FUNCTION,
                                MyDatabaseId,
                                proid);
}

References MyDatabaseId, pgstat_create_transactional(), and PGSTAT_KIND_FUNCTION.

Referenced by ProcedureCreate().

pgstat_create_relation()

void pgstat_create_relation

(

Relation

rel

)

Definition at line 170 of file pgstat_relation.c.

{
    pgstat_create_transactional(PGSTAT_KIND_RELATION,
                                rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
                                RelationGetRelid(rel));
}

References InvalidOid, MyDatabaseId, pgstat_create_transactional(), PGSTAT_KIND_RELATION, RelationData::rd_rel, and RelationGetRelid.

Referenced by heap_create().

pgstat_create_replslot()

void pgstat_create_replslot

(

struct ReplicationSlot *

slot

)

Definition at line 111 of file pgstat_replslot.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_ReplSlot *shstatent;
 
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_REPLSLOT, InvalidOid,
                                            ReplicationSlotIndex(slot), false);
    shstatent = (PgStatShared_ReplSlot *) entry_ref->shared_stats;
 
    /*
     * NB: need to accept that there might be stats from an older slot, e.g.
     * if we previously crashed after dropping a slot.
     */
    memset(&shstatent->stats, 0, sizeof(shstatent->stats));
 
    pgstat_unlock_entry(entry_ref);
}

References InvalidOid, pgstat_get_entry_ref_locked(), PGSTAT_KIND_REPLSLOT, pgstat_unlock_entry(), ReplicationSlotIndex(), PgStat_EntryRef::shared_stats, and PgStatShared_ReplSlot::stats.

Referenced by ReplicationSlotCreate().

pgstat_create_subscription()

void pgstat_create_subscription

(

Oid

subid

)

Definition at line 46 of file pgstat_subscription.c.

{
    /* Ensures that stats are dropped if transaction rolls back */
    pgstat_create_transactional(PGSTAT_KIND_SUBSCRIPTION,
                                InvalidOid, subid);
 
    /* Create and initialize the subscription stats entry */
    pgstat_get_entry_ref(PGSTAT_KIND_SUBSCRIPTION, InvalidOid, subid,
                         true, NULL);
    pgstat_reset_entry(PGSTAT_KIND_SUBSCRIPTION, InvalidOid, subid, 0);
}

References InvalidOid, pgstat_create_transactional(), pgstat_get_entry_ref(), PGSTAT_KIND_SUBSCRIPTION, and pgstat_reset_entry().

Referenced by CreateSubscription().

pgstat_discard_stats()

void pgstat_discard_stats

(

void

)

Definition at line 415 of file pgstat.c.

{
    int         ret;
 
    /* NB: this needs to be done even in single user mode */
 
    ret = unlink(PGSTAT_STAT_PERMANENT_FILENAME);
    if (ret != 0)
    {
        if (errno == ENOENT)
            elog(DEBUG2,
                 "didn't need to unlink permanent stats file \"%s\" - didn't exist",
                 PGSTAT_STAT_PERMANENT_FILENAME);
        else
            ereport(LOG,
                    (errcode_for_file_access(),
                     errmsg("could not unlink permanent statistics file \"%s\": %m",
                            PGSTAT_STAT_PERMANENT_FILENAME)));
    }
    else
    {
        ereport(DEBUG2,
                (errcode_for_file_access(),
                 errmsg_internal("unlinked permanent statistics file \"%s\"",
                                 PGSTAT_STAT_PERMANENT_FILENAME)));
    }
 
    /*
     * Reset stats contents. This will set reset timestamps of fixed-numbered
     * stats to the current time (no variable stats exist).
     */
    pgstat_reset_after_failure();
}

References DEBUG2, elog(), ereport, errcode_for_file_access(), errmsg(), errmsg_internal(), LOG, pgstat_reset_after_failure(), and PGSTAT_STAT_PERMANENT_FILENAME.

Referenced by StartupXLOG().

pgstat_drop_database()

void pgstat_drop_database

(

Oid

databaseid

)

Definition at line 44 of file pgstat_database.c.

{
    pgstat_drop_transactional(PGSTAT_KIND_DATABASE, databaseid, InvalidOid);
}

References InvalidOid, pgstat_drop_transactional(), and PGSTAT_KIND_DATABASE.

Referenced by dropdb().

pgstat_drop_function()

void pgstat_drop_function

(

Oid

proid

)

Definition at line 60 of file pgstat_function.c.

{
    pgstat_drop_transactional(PGSTAT_KIND_FUNCTION,
                              MyDatabaseId,
                              proid);
}

References MyDatabaseId, pgstat_drop_transactional(), and PGSTAT_KIND_FUNCTION.

Referenced by RemoveFunctionById().

pgstat_drop_relation()

void pgstat_drop_relation

(

Relation

rel

)

Definition at line 181 of file pgstat_relation.c.

{
    int         nest_level = GetCurrentTransactionNestLevel();
    PgStat_TableStatus *pgstat_info;
 
    pgstat_drop_transactional(PGSTAT_KIND_RELATION,
                              rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
                              RelationGetRelid(rel));
 
    if (!pgstat_should_count_relation(rel))
        return;
 
    /*
     * Transactionally set counters to 0. That ensures that accesses to
     * pg_stat_xact_all_tables inside the transaction show 0.
     */
    pgstat_info = rel->pgstat_info;
    if (pgstat_info->trans &&
        pgstat_info->trans->nest_level == nest_level)
    {
        save_truncdrop_counters(pgstat_info->trans, true);
        pgstat_info->trans->tuples_inserted = 0;
        pgstat_info->trans->tuples_updated = 0;
        pgstat_info->trans->tuples_deleted = 0;
    }
}

References GetCurrentTransactionNestLevel(), InvalidOid, MyDatabaseId, PgStat_TableXactStatus::nest_level, pgstat_drop_transactional(), RelationData::pgstat_info, PGSTAT_KIND_RELATION, pgstat_should_count_relation, RelationData::rd_rel, RelationGetRelid, save_truncdrop_counters(), PgStat_TableStatus::trans, PgStat_TableXactStatus::tuples_deleted, PgStat_TableXactStatus::tuples_inserted, and PgStat_TableXactStatus::tuples_updated.

Referenced by heap_drop_with_catalog(), and index_drop().

pgstat_drop_replslot()

void pgstat_drop_replslot

(

struct ReplicationSlot *

slot

)

Definition at line 154 of file pgstat_replslot.c.

{
    pgstat_drop_entry(PGSTAT_KIND_REPLSLOT, InvalidOid,
                      ReplicationSlotIndex(slot));
}

References InvalidOid, pgstat_drop_entry(), PGSTAT_KIND_REPLSLOT, and ReplicationSlotIndex().

Referenced by ReplicationSlotDropPtr().

pgstat_drop_subscription()

void pgstat_drop_subscription

(

Oid

subid

)

Definition at line 64 of file pgstat_subscription.c.

{
    pgstat_drop_transactional(PGSTAT_KIND_SUBSCRIPTION,
                              InvalidOid, subid);
}

References InvalidOid, pgstat_drop_transactional(), and PGSTAT_KIND_SUBSCRIPTION.

Referenced by DropSubscription().

pgstat_end_function_usage()

void pgstat_end_function_usage	(	PgStat_FunctionCallUsage *	fcu,
		bool	finalize
	)

Definition at line 146 of file pgstat_function.c.

{
    PgStat_FunctionCounts *fs = fcu->fs;
    instr_time  total;
    instr_time  others;
    instr_time  self;
 
    /* stats not wanted? */
    if (fs == NULL)
        return;
 
    /* total elapsed time in this function call */
    INSTR_TIME_SET_CURRENT(total);
    INSTR_TIME_SUBTRACT(total, fcu->start);
 
    /* self usage: elapsed minus anything already charged to other calls */
    others = total_func_time;
    INSTR_TIME_SUBTRACT(others, fcu->save_total);
    self = total;
    INSTR_TIME_SUBTRACT(self, others);
 
    /* update backend-wide total time */
    INSTR_TIME_ADD(total_func_time, self);
 
    /*
     * Compute the new total_time as the total elapsed time added to the
     * pre-call value of total_time.  This is necessary to avoid
     * double-counting any time taken by recursive calls of myself.  (We do
     * not need any similar kluge for self time, since that already excludes
     * any recursive calls.)
     */
    INSTR_TIME_ADD(total, fcu->save_f_total_time);
 
    /* update counters in function stats table */
    if (finalize)
        fs->numcalls++;
    fs->total_time = total;
    INSTR_TIME_ADD(fs->self_time, self);
}

References PgStat_FunctionCallUsage::fs, INSTR_TIME_ADD, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, PgStat_FunctionCounts::numcalls, PgStat_FunctionCallUsage::save_f_total_time, PgStat_FunctionCallUsage::save_total, PgStat_FunctionCounts::self_time, PgStat_FunctionCallUsage::start, total_func_time, and PgStat_FunctionCounts::total_time.

Referenced by call_pltcl_start_proc(), EventTriggerInvoke(), ExecCallTriggerFunc(), ExecEvalFuncExprFusage(), ExecEvalFuncExprStrictFusage(), ExecMakeFunctionResultSet(), ExecMakeTableFunctionResult(), ExecuteCallStmt(), and fmgr_security_definer().

pgstat_execute_transactional_drops()

void pgstat_execute_transactional_drops	(	int	ndrops,
		struct xl_xact_stats_item *	items,
		bool	is_redo
	)

Definition at line 313 of file pgstat_xact.c.

{
    int         not_freed_count = 0;
 
    if (ndrops == 0)
        return;
 
    for (int i = 0; i < ndrops; i++)
    {
        xl_xact_stats_item *it = &items[i];
 
        if (!pgstat_drop_entry(it->kind, it->dboid, it->objoid))
            not_freed_count++;
    }
 
    if (not_freed_count > 0)
        pgstat_request_entry_refs_gc();
}

References xl_xact_stats_item::dboid, i, xl_xact_stats_item::kind, xl_xact_stats_item::objoid, pgstat_drop_entry(), and pgstat_request_entry_refs_gc().

Referenced by FinishPreparedTransaction(), xact_redo_abort(), and xact_redo_commit().

pgstat_fetch_replslot()

PgStat_StatReplSlotEntry* pgstat_fetch_replslot

(

NameData

slotname

)

Definition at line 165 of file pgstat_replslot.c.

{
    int         idx = get_replslot_index(NameStr(slotname));
 
    if (idx == -1)
        return NULL;
 
    return (PgStat_StatReplSlotEntry *)
        pgstat_fetch_entry(PGSTAT_KIND_REPLSLOT, InvalidOid, idx);
}

References get_replslot_index(), idx(), InvalidOid, NameStr, pgstat_fetch_entry(), and PGSTAT_KIND_REPLSLOT.

Referenced by pg_stat_get_replication_slot().

pgstat_fetch_slru()

PgStat_SLRUStats* pgstat_fetch_slru

(

void

)

Definition at line 105 of file pgstat_slru.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_SLRU);
 
    return pgStatLocal.snapshot.slru;
}

References PGSTAT_KIND_SLRU, pgstat_snapshot_fixed(), pgStatLocal, PgStat_Snapshot::slru, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_slru().

pgstat_fetch_stat_archiver()

PgStat_ArchiverStats* pgstat_fetch_stat_archiver

(

void

)

Definition at line 58 of file pgstat_archiver.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_ARCHIVER);
 
    return &pgStatLocal.snapshot.archiver;
}

References PgStat_Snapshot::archiver, PGSTAT_KIND_ARCHIVER, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_archiver().

pgstat_fetch_stat_bgwriter()

PgStat_BgWriterStats* pgstat_fetch_stat_bgwriter

(

void

)

Definition at line 71 of file pgstat_bgwriter.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_BGWRITER);
 
    return &pgStatLocal.snapshot.bgwriter;
}

References PgStat_Snapshot::bgwriter, PGSTAT_KIND_BGWRITER, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_bgwriter_buf_written_clean(), pg_stat_get_bgwriter_maxwritten_clean(), pg_stat_get_bgwriter_stat_reset_time(), and pg_stat_get_buf_alloc().

pgstat_fetch_stat_checkpointer()

PgStat_CheckpointerStats* pgstat_fetch_stat_checkpointer

(

void

)

Definition at line 79 of file pgstat_checkpointer.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_CHECKPOINTER);
 
    return &pgStatLocal.snapshot.checkpointer;
}

References PgStat_Snapshot::checkpointer, PGSTAT_KIND_CHECKPOINTER, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_bgwriter_buf_written_checkpoints(), pg_stat_get_bgwriter_requested_checkpoints(), pg_stat_get_bgwriter_timed_checkpoints(), pg_stat_get_buf_fsync_backend(), pg_stat_get_buf_written_backend(), pg_stat_get_checkpoint_sync_time(), and pg_stat_get_checkpoint_write_time().

pgstat_fetch_stat_dbentry()

PgStat_StatDBEntry* pgstat_fetch_stat_dbentry

(

Oid

dboid

)

Definition at line 239 of file pgstat_database.c.

{
    return (PgStat_StatDBEntry *)
        pgstat_fetch_entry(PGSTAT_KIND_DATABASE, dboid, InvalidOid);
}

References InvalidOid, pgstat_fetch_entry(), and PGSTAT_KIND_DATABASE.

Referenced by do_start_worker(), pg_stat_get_db_checksum_failures(), pg_stat_get_db_checksum_last_failure(), pg_stat_get_db_conflict_all(), pg_stat_get_db_stat_reset_time(), and rebuild_database_list().

pgstat_fetch_stat_funcentry()

PgStat_StatFuncEntry* pgstat_fetch_stat_funcentry

(

Oid

func_id

)

Definition at line 239 of file pgstat_function.c.

{
    return (PgStat_StatFuncEntry *)
        pgstat_fetch_entry(PGSTAT_KIND_FUNCTION, MyDatabaseId, func_id);
}

References MyDatabaseId, pgstat_fetch_entry(), and PGSTAT_KIND_FUNCTION.

Referenced by pg_stat_get_function_calls().

pgstat_fetch_stat_io()

PgStat_IO* pgstat_fetch_stat_io

(

void

)

Definition at line 79 of file pgstat_io.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_IO);
 
    return &pgStatLocal.snapshot.io;
}

References PgStat_Snapshot::io, PGSTAT_KIND_IO, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_io().

pgstat_fetch_stat_subscription()

PgStat_StatSubEntry* pgstat_fetch_stat_subscription

(

Oid

subid

)

Definition at line 75 of file pgstat_subscription.c.

{
    return (PgStat_StatSubEntry *)
        pgstat_fetch_entry(PGSTAT_KIND_SUBSCRIPTION, InvalidOid, subid);
}

References InvalidOid, pgstat_fetch_entry(), and PGSTAT_KIND_SUBSCRIPTION.

Referenced by pg_stat_get_subscription_stats().

pgstat_fetch_stat_tabentry()

PgStat_StatTabEntry* pgstat_fetch_stat_tabentry

(

Oid

relid

)

Definition at line 457 of file pgstat_relation.c.

{
    return pgstat_fetch_stat_tabentry_ext(IsSharedRelation(relid), relid);
}

References IsSharedRelation(), and pgstat_fetch_stat_tabentry_ext().

pgstat_fetch_stat_tabentry_ext()

PgStat_StatTabEntry* pgstat_fetch_stat_tabentry_ext	(	bool	shared,
		Oid	reloid
	)

Definition at line 467 of file pgstat_relation.c.

{
    Oid         dboid = (shared ? InvalidOid : MyDatabaseId);
 
    return (PgStat_StatTabEntry *)
        pgstat_fetch_entry(PGSTAT_KIND_RELATION, dboid, reloid);
}

References InvalidOid, MyDatabaseId, pgstat_fetch_entry(), and PGSTAT_KIND_RELATION.

Referenced by do_autovacuum(), pgstat_copy_relation_stats(), pgstat_fetch_stat_tabentry(), and recheck_relation_needs_vacanalyze().

pgstat_fetch_stat_wal()

PgStat_WalStats* pgstat_fetch_stat_wal

(

void

)

Definition at line 55 of file pgstat_wal.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_WAL);
 
    return &pgStatLocal.snapshot.wal;
}

References PGSTAT_KIND_WAL, pgstat_snapshot_fixed(), pgStatLocal, PgStat_LocalState::snapshot, and PgStat_Snapshot::wal.

Referenced by pg_stat_get_wal().

pgstat_force_next_flush()

void pgstat_force_next_flush

(

void

)

Definition at line 679 of file pgstat.c.

{
    pgStatForceNextFlush = true;
}

References pgStatForceNextFlush.

Referenced by pg_stat_force_next_flush().

pgstat_get_io_context_name()

const char* pgstat_get_io_context_name

(

IOContext

io_context

)

Definition at line 134 of file pgstat_io.c.

{
    switch (io_context)
    {
        case IOCONTEXT_BULKREAD:
            return "bulkread";
        case IOCONTEXT_BULKWRITE:
            return "bulkwrite";
        case IOCONTEXT_NORMAL:
            return "normal";
        case IOCONTEXT_VACUUM:
            return "vacuum";
    }
 
    elog(ERROR, "unrecognized IOContext value: %d", io_context);
    pg_unreachable();
}

References elog(), ERROR, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, and pg_unreachable.

Referenced by pg_stat_get_io().

pgstat_get_io_object_name()

const char* pgstat_get_io_object_name

(

IOObject

io_object

)

Definition at line 153 of file pgstat_io.c.

{
    switch (io_object)
    {
        case IOOBJECT_RELATION:
            return "relation";
        case IOOBJECT_TEMP_RELATION:
            return "temp relation";
    }
 
    elog(ERROR, "unrecognized IOObject value: %d", io_object);
    pg_unreachable();
}

References elog(), ERROR, IOOBJECT_RELATION, IOOBJECT_TEMP_RELATION, and pg_unreachable.

Referenced by pg_stat_get_io().

pgstat_get_kind_from_str()

PgStat_Kind pgstat_get_kind_from_str

(

char *

kind_str

)

Definition at line 1214 of file pgstat.c.

{
    for (int kind = PGSTAT_KIND_FIRST_VALID; kind <= PGSTAT_KIND_LAST; kind++)
    {
        if (pg_strcasecmp(kind_str, pgstat_kind_infos[kind].name) == 0)
            return kind;
    }
 
    ereport(ERROR,
            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
             errmsg("invalid statistics kind: \"%s\"", kind_str)));
    return PGSTAT_KIND_DATABASE;    /* avoid compiler warnings */
}

References ereport, errcode(), errmsg(), ERROR, name, pg_strcasecmp(), PGSTAT_KIND_DATABASE, PGSTAT_KIND_FIRST_VALID, pgstat_kind_infos, and PGSTAT_KIND_LAST.

Referenced by pg_stat_have_stats().

pgstat_get_slru_index()

int pgstat_get_slru_index

(

const char *

name

)

Definition at line 132 of file pgstat_slru.c.

{
    int         i;
 
    for (i = 0; i < SLRU_NUM_ELEMENTS; i++)
    {
        if (strcmp(slru_names[i], name) == 0)
            return i;
    }
 
    /* return index of the last entry (which is the "other" one) */
    return (SLRU_NUM_ELEMENTS - 1);
}

References i, name, slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pgstat_reset_slru(), and SimpleLruInit().

pgstat_get_slru_name()

const char* pgstat_get_slru_name

(

int

slru_idx

)

Definition at line 118 of file pgstat_slru.c.

{
    if (slru_idx < 0 || slru_idx >= SLRU_NUM_ELEMENTS)
        return NULL;
 
    return slru_names[slru_idx];
}

References slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pg_stat_get_slru().

pgstat_get_stat_snapshot_timestamp()

TimestampTz pgstat_get_stat_snapshot_timestamp

(

bool *

have_snapshot

)

Definition at line 886 of file pgstat.c.

{
    if (pgStatLocal.snapshot.mode == PGSTAT_FETCH_CONSISTENCY_SNAPSHOT)
    {
        *have_snapshot = true;
        return pgStatLocal.snapshot.snapshot_timestamp;
    }
 
    *have_snapshot = false;
 
    return 0;
}

References PgStat_Snapshot::mode, PGSTAT_FETCH_CONSISTENCY_SNAPSHOT, pgStatLocal, PgStat_LocalState::snapshot, and PgStat_Snapshot::snapshot_timestamp.

Referenced by pg_stat_get_snapshot_timestamp().

pgstat_get_transactional_drops()

int pgstat_get_transactional_drops	(	bool	isCommit,
		struct xl_xact_stats_item **	items
	)

Definition at line 271 of file pgstat_xact.c.

{
    PgStat_SubXactStatus *xact_state = pgStatXactStack;
    int         nitems = 0;
    dlist_iter  iter;
 
    if (xact_state == NULL)
        return 0;
 
    /*
     * We expect to be called for subtransaction abort (which logs a WAL
     * record), but not for subtransaction commit (which doesn't).
     */
    Assert(!isCommit || xact_state->nest_level == 1);
    Assert(!isCommit || xact_state->prev == NULL);
 
    *items = palloc(dclist_count(&xact_state->pending_drops)
                    * sizeof(xl_xact_stats_item));
 
    dclist_foreach(iter, &xact_state->pending_drops)
    {
        PgStat_PendingDroppedStatsItem *pending =
        dclist_container(PgStat_PendingDroppedStatsItem, node, iter.cur);
 
        if (isCommit && pending->is_create)
            continue;
        if (!isCommit && !pending->is_create)
            continue;
 
        Assert(nitems < dclist_count(&xact_state->pending_drops));
        (*items)[nitems++] = pending->item;
    }
 
    return nitems;
}

References Assert(), dlist_iter::cur, dclist_container, dclist_count(), dclist_foreach, PgStat_PendingDroppedStatsItem::is_create, PgStat_PendingDroppedStatsItem::item, PgStat_SubXactStatus::nest_level, nitems, palloc(), PgStat_SubXactStatus::pending_drops, pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by RecordTransactionAbort(), RecordTransactionCommit(), and StartPrepare().

pgstat_have_entry()

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

Definition at line 900 of file pgstat.c.

{
    /* fixed-numbered stats always exist */
    if (pgstat_get_kind_info(kind)->fixed_amount)
        return true;
 
    return pgstat_get_entry_ref(kind, dboid, objoid, false, NULL) != NULL;
}

References pgstat_get_entry_ref(), and pgstat_get_kind_info().

Referenced by pg_stat_have_stats().

pgstat_init_function_usage()

void pgstat_init_function_usage	(	struct FunctionCallInfoBaseData *	fcinfo,
		PgStat_FunctionCallUsage *	fcu
	)

pgstat_init_relation()

void pgstat_init_relation

(

Relation

rel

)

Definition at line 93 of file pgstat_relation.c.

{
    char        relkind = rel->rd_rel->relkind;
 
    /*
     * We only count stats for relations with storage and partitioned tables
     */
    if (!RELKIND_HAS_STORAGE(relkind) && relkind != RELKIND_PARTITIONED_TABLE)
    {
        rel->pgstat_enabled = false;
        rel->pgstat_info = NULL;
        return;
    }
 
    if (!pgstat_track_counts)
    {
        if (rel->pgstat_info)
            pgstat_unlink_relation(rel);
 
        /* We're not counting at all */
        rel->pgstat_enabled = false;
        rel->pgstat_info = NULL;
        return;
    }
 
    rel->pgstat_enabled = true;
}

References RelationData::pgstat_enabled, RelationData::pgstat_info, pgstat_track_counts, pgstat_unlink_relation(), and RelationData::rd_rel.

Referenced by relation_open(), and try_relation_open().

pgstat_initialize()

void pgstat_initialize

(

void

)

Definition at line 533 of file pgstat.c.

{
    Assert(!pgstat_is_initialized);
 
    pgstat_attach_shmem();
 
    pgstat_init_wal();
 
    /* Set up a process-exit hook to clean up */
    before_shmem_exit(pgstat_shutdown_hook, 0);
 
#ifdef USE_ASSERT_CHECKING
    pgstat_is_initialized = true;
#endif
}

References Assert(), before_shmem_exit(), pgstat_attach_shmem(), pgstat_init_wal(), and pgstat_shutdown_hook().

Referenced by BaseInit().

pgstat_report_analyze()

void pgstat_report_analyze	(	Relation	rel,
		PgStat_Counter	livetuples,
		PgStat_Counter	deadtuples,
		bool	resetcounter
	)

Definition at line 278 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Relation *shtabentry;
    PgStat_StatTabEntry *tabentry;
    Oid         dboid = (rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId);
 
    if (!pgstat_track_counts)
        return;
 
    /*
     * Unlike VACUUM, ANALYZE might be running inside a transaction that has
     * already inserted and/or deleted rows in the target table. ANALYZE will
     * have counted such rows as live or dead respectively. Because we will
     * report our counts of such rows at transaction end, we should subtract
     * off these counts from the update we're making now, else they'll be
     * double-counted after commit.  (This approach also ensures that the
     * shared stats entry ends up with the right numbers if we abort instead
     * of committing.)
     *
     * Waste no time on partitioned tables, though.
     */
    if (pgstat_should_count_relation(rel) &&
        rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
    {
        PgStat_TableXactStatus *trans;
 
        for (trans = rel->pgstat_info->trans; trans; trans = trans->upper)
        {
            livetuples -= trans->tuples_inserted - trans->tuples_deleted;
            deadtuples -= trans->tuples_updated + trans->tuples_deleted;
        }
        /* count stuff inserted by already-aborted subxacts, too */
        deadtuples -= rel->pgstat_info->counts.delta_dead_tuples;
        /* Since ANALYZE's counts are estimates, we could have underflowed */
        livetuples = Max(livetuples, 0);
        deadtuples = Max(deadtuples, 0);
    }
 
    /* block acquiring lock for the same reason as pgstat_report_autovac() */
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION, dboid,
                                            RelationGetRelid(rel),
                                            false);
    /* can't get dropped while accessed */
    Assert(entry_ref != NULL && entry_ref->shared_stats != NULL);
 
    shtabentry = (PgStatShared_Relation *) entry_ref->shared_stats;
    tabentry = &shtabentry->stats;
 
    tabentry->live_tuples = livetuples;
    tabentry->dead_tuples = deadtuples;
 
    /*
     * If commanded, reset mod_since_analyze to zero.  This forgets any
     * changes that were committed while the ANALYZE was in progress, but we
     * have no good way to estimate how many of those there were.
     */
    if (resetcounter)
        tabentry->mod_since_analyze = 0;
 
    if (IsAutoVacuumWorkerProcess())
    {
        tabentry->last_autoanalyze_time = GetCurrentTimestamp();
        tabentry->autoanalyze_count++;
    }
    else
    {
        tabentry->last_analyze_time = GetCurrentTimestamp();
        tabentry->analyze_count++;
    }
 
    pgstat_unlock_entry(entry_ref);
 
    /* see pgstat_report_vacuum() */
    pgstat_flush_io(false);
}

References PgStat_StatTabEntry::analyze_count, Assert(), PgStat_StatTabEntry::autoanalyze_count, PgStat_TableStatus::counts, PgStat_StatTabEntry::dead_tuples, PgStat_TableCounts::delta_dead_tuples, GetCurrentTimestamp(), if(), InvalidOid, IsAutoVacuumWorkerProcess(), PgStat_StatTabEntry::last_analyze_time, PgStat_StatTabEntry::last_autoanalyze_time, PgStat_StatTabEntry::live_tuples, Max, PgStat_StatTabEntry::mod_since_analyze, MyDatabaseId, pgstat_flush_io(), pgstat_get_entry_ref_locked(), RelationData::pgstat_info, PGSTAT_KIND_RELATION, pgstat_should_count_relation, pgstat_track_counts, pgstat_unlock_entry(), RelationData::rd_rel, RelationGetRelid, PgStat_EntryRef::shared_stats, PgStatShared_Relation::stats, PgStat_TableStatus::trans, and trans.

Referenced by do_analyze_rel().

pgstat_report_archiver()

void pgstat_report_archiver	(	const char *	xlog,
		bool	failed
	)

Definition at line 28 of file pgstat_archiver.c.

{
    PgStatShared_Archiver *stats_shmem = &pgStatLocal.shmem->archiver;
    TimestampTz now = GetCurrentTimestamp();
 
    pgstat_begin_changecount_write(&stats_shmem->changecount);
 
    if (failed)
    {
        ++stats_shmem->stats.failed_count;
        memcpy(&stats_shmem->stats.last_failed_wal, xlog,
               sizeof(stats_shmem->stats.last_failed_wal));
        stats_shmem->stats.last_failed_timestamp = now;
    }
    else
    {
        ++stats_shmem->stats.archived_count;
        memcpy(&stats_shmem->stats.last_archived_wal, xlog,
               sizeof(stats_shmem->stats.last_archived_wal));
        stats_shmem->stats.last_archived_timestamp = now;
    }
 
    pgstat_end_changecount_write(&stats_shmem->changecount);
}

References PgStat_ArchiverStats::archived_count, PgStat_ShmemControl::archiver, PgStatShared_Archiver::changecount, PgStat_ArchiverStats::failed_count, GetCurrentTimestamp(), PgStat_ArchiverStats::last_archived_timestamp, PgStat_ArchiverStats::last_archived_wal, PgStat_ArchiverStats::last_failed_timestamp, PgStat_ArchiverStats::last_failed_wal, now(), pgstat_begin_changecount_write(), pgstat_end_changecount_write(), pgStatLocal, PgStat_LocalState::shmem, and PgStatShared_Archiver::stats.

Referenced by pgarch_ArchiverCopyLoop().

pgstat_report_autovac()

void pgstat_report_autovac

(

Oid

dboid

)

Definition at line 55 of file pgstat_database.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Database *dbentry;
 
    /* can't get here in single user mode */
    Assert(IsUnderPostmaster);
 
    /*
     * End-of-vacuum is reported instantly. Report the start the same way for
     * consistency. Vacuum doesn't run frequently and is a long-lasting
     * operation so it doesn't matter if we get blocked here a little.
     */
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_DATABASE,
                                            dboid, InvalidOid, false);
 
    dbentry = (PgStatShared_Database *) entry_ref->shared_stats;
    dbentry->stats.last_autovac_time = GetCurrentTimestamp();
 
    pgstat_unlock_entry(entry_ref);
}

References Assert(), GetCurrentTimestamp(), InvalidOid, IsUnderPostmaster, PgStat_StatDBEntry::last_autovac_time, pgstat_get_entry_ref_locked(), PGSTAT_KIND_DATABASE, pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, and PgStatShared_Database::stats.

Referenced by AutoVacWorkerMain().

pgstat_report_bgwriter()

void pgstat_report_bgwriter

(

void

)

Definition at line 30 of file pgstat_bgwriter.c.

{
    PgStatShared_BgWriter *stats_shmem = &pgStatLocal.shmem->bgwriter;
    static const PgStat_BgWriterStats all_zeroes;
 
    Assert(!pgStatLocal.shmem->is_shutdown);
    pgstat_assert_is_up();
 
    /*
     * This function can be called even if nothing at all has happened. In
     * this case, avoid unnecessarily modifying the stats entry.
     */
    if (memcmp(&PendingBgWriterStats, &all_zeroes, sizeof(all_zeroes)) == 0)
        return;
 
    pgstat_begin_changecount_write(&stats_shmem->changecount);
 
#define BGWRITER_ACC(fld) stats_shmem->stats.fld += PendingBgWriterStats.fld
    BGWRITER_ACC(buf_written_clean);
    BGWRITER_ACC(maxwritten_clean);
    BGWRITER_ACC(buf_alloc);
#undef BGWRITER_ACC
 
    pgstat_end_changecount_write(&stats_shmem->changecount);
 
    /*
     * Clear out the statistics buffer, so it can be re-used.
     */
    MemSet(&PendingBgWriterStats, 0, sizeof(PendingBgWriterStats));
 
    /*
     * Report IO statistics
     */
    pgstat_flush_io(false);
}

References Assert(), PgStat_ShmemControl::bgwriter, BGWRITER_ACC, PgStatShared_BgWriter::changecount, PgStat_ShmemControl::is_shutdown, MemSet, PendingBgWriterStats, pgstat_assert_is_up, pgstat_begin_changecount_write(), pgstat_end_changecount_write(), pgstat_flush_io(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by BackgroundWriterMain().

pgstat_report_checkpointer()

void pgstat_report_checkpointer

(

void

)

Definition at line 30 of file pgstat_checkpointer.c.

{
    /* We assume this initializes to zeroes */
    static const PgStat_CheckpointerStats all_zeroes;
    PgStatShared_Checkpointer *stats_shmem = &pgStatLocal.shmem->checkpointer;
 
    Assert(!pgStatLocal.shmem->is_shutdown);
    pgstat_assert_is_up();
 
    /*
     * This function can be called even if nothing at all has happened. In
     * this case, avoid unnecessarily modifying the stats entry.
     */
    if (memcmp(&PendingCheckpointerStats, &all_zeroes,
               sizeof(all_zeroes)) == 0)
        return;
 
    pgstat_begin_changecount_write(&stats_shmem->changecount);
 
#define CHECKPOINTER_ACC(fld) stats_shmem->stats.fld += PendingCheckpointerStats.fld
    CHECKPOINTER_ACC(timed_checkpoints);
    CHECKPOINTER_ACC(requested_checkpoints);
    CHECKPOINTER_ACC(checkpoint_write_time);
    CHECKPOINTER_ACC(checkpoint_sync_time);
    CHECKPOINTER_ACC(buf_written_checkpoints);
    CHECKPOINTER_ACC(buf_written_backend);
    CHECKPOINTER_ACC(buf_fsync_backend);
#undef CHECKPOINTER_ACC
 
    pgstat_end_changecount_write(&stats_shmem->changecount);
 
    /*
     * Clear out the statistics buffer, so it can be re-used.
     */
    MemSet(&PendingCheckpointerStats, 0, sizeof(PendingCheckpointerStats));
 
    /*
     * Report IO statistics
     */
    pgstat_flush_io(false);
}

References Assert(), PgStatShared_Checkpointer::changecount, PgStat_ShmemControl::checkpointer, CHECKPOINTER_ACC, PgStat_ShmemControl::is_shutdown, MemSet, PendingCheckpointerStats, pgstat_assert_is_up, pgstat_begin_changecount_write(), pgstat_end_changecount_write(), pgstat_flush_io(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by CheckpointerMain(), CheckpointWriteDelay(), and HandleCheckpointerInterrupts().

pgstat_report_checksum_failure()

void pgstat_report_checksum_failure

(

void

)

Definition at line 163 of file pgstat_database.c.

{
    pgstat_report_checksum_failures_in_db(MyDatabaseId, 1);
}

References MyDatabaseId, and pgstat_report_checksum_failures_in_db().

Referenced by PageIsVerifiedExtended().

pgstat_report_checksum_failures_in_db()

void pgstat_report_checksum_failures_in_db	(	Oid	dboid,
		int	failurecount
	)

Definition at line 137 of file pgstat_database.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Database *sharedent;
 
    if (!pgstat_track_counts)
        return;
 
    /*
     * Update the shared stats directly - checksum failures should never be
     * common enough for that to be a problem.
     */
    entry_ref =
        pgstat_get_entry_ref_locked(PGSTAT_KIND_DATABASE, dboid, InvalidOid, false);
 
    sharedent = (PgStatShared_Database *) entry_ref->shared_stats;
    sharedent->stats.checksum_failures += failurecount;
    sharedent->stats.last_checksum_failure = GetCurrentTimestamp();
 
    pgstat_unlock_entry(entry_ref);
}

References PgStat_StatDBEntry::checksum_failures, GetCurrentTimestamp(), InvalidOid, PgStat_StatDBEntry::last_checksum_failure, pgstat_get_entry_ref_locked(), PGSTAT_KIND_DATABASE, pgstat_track_counts, pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, and PgStatShared_Database::stats.

Referenced by pgstat_report_checksum_failure(), and sendFile().

pgstat_report_connect()

void pgstat_report_connect

(

Oid

dboid

)

Definition at line 188 of file pgstat_database.c.

{
    PgStat_StatDBEntry *dbentry;
 
    if (!pgstat_should_report_connstat())
        return;
 
    pgLastSessionReportTime = MyStartTimestamp;
 
    dbentry = pgstat_prep_database_pending(MyDatabaseId);
    dbentry->sessions++;
}

References MyDatabaseId, MyStartTimestamp, pgLastSessionReportTime, pgstat_prep_database_pending(), pgstat_should_report_connstat(), and PgStat_StatDBEntry::sessions.

Referenced by PostgresMain().

pgstat_report_deadlock()

void pgstat_report_deadlock

(

void

)

Definition at line 122 of file pgstat_database.c.

{
    PgStat_StatDBEntry *dbent;
 
    if (!pgstat_track_counts)
        return;
 
    dbent = pgstat_prep_database_pending(MyDatabaseId);
    dbent->deadlocks++;
}

References PgStat_StatDBEntry::deadlocks, MyDatabaseId, pgstat_prep_database_pending(), and pgstat_track_counts.

Referenced by DeadLockReport().

pgstat_report_recovery_conflict()

void pgstat_report_recovery_conflict

(

int

reason

)

Definition at line 81 of file pgstat_database.c.

{
    PgStat_StatDBEntry *dbentry;
 
    Assert(IsUnderPostmaster);
    if (!pgstat_track_counts)
        return;
 
    dbentry = pgstat_prep_database_pending(MyDatabaseId);
 
    switch (reason)
    {
        case PROCSIG_RECOVERY_CONFLICT_DATABASE:
 
            /*
             * Since we drop the information about the database as soon as it
             * replicates, there is no point in counting these conflicts.
             */
            break;
        case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
            dbentry->conflict_tablespace++;
            break;
        case PROCSIG_RECOVERY_CONFLICT_LOCK:
            dbentry->conflict_lock++;
            break;
        case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
            dbentry->conflict_snapshot++;
            break;
        case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
            dbentry->conflict_bufferpin++;
            break;
        case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
            dbentry->conflict_startup_deadlock++;
            break;
    }
}

References Assert(), PgStat_StatDBEntry::conflict_bufferpin, PgStat_StatDBEntry::conflict_lock, PgStat_StatDBEntry::conflict_snapshot, PgStat_StatDBEntry::conflict_startup_deadlock, PgStat_StatDBEntry::conflict_tablespace, IsUnderPostmaster, MyDatabaseId, pgstat_prep_database_pending(), pgstat_track_counts, PROCSIG_RECOVERY_CONFLICT_BUFFERPIN, PROCSIG_RECOVERY_CONFLICT_DATABASE, PROCSIG_RECOVERY_CONFLICT_LOCK, PROCSIG_RECOVERY_CONFLICT_SNAPSHOT, PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK, and PROCSIG_RECOVERY_CONFLICT_TABLESPACE.

Referenced by ProcessInterrupts().

pgstat_report_replslot()

void pgstat_report_replslot	(	struct ReplicationSlot *	slot,
		const PgStat_StatReplSlotEntry *	repSlotStat
	)

Definition at line 78 of file pgstat_replslot.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_ReplSlot *shstatent;
    PgStat_StatReplSlotEntry *statent;
 
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_REPLSLOT, InvalidOid,
                                            ReplicationSlotIndex(slot), false);
    shstatent = (PgStatShared_ReplSlot *) entry_ref->shared_stats;
    statent = &shstatent->stats;
 
    /* Update the replication slot statistics */
#define REPLSLOT_ACC(fld) statent->fld += repSlotStat->fld
    REPLSLOT_ACC(spill_txns);
    REPLSLOT_ACC(spill_count);
    REPLSLOT_ACC(spill_bytes);
    REPLSLOT_ACC(stream_txns);
    REPLSLOT_ACC(stream_count);
    REPLSLOT_ACC(stream_bytes);
    REPLSLOT_ACC(total_txns);
    REPLSLOT_ACC(total_bytes);
#undef REPLSLOT_ACC
 
    pgstat_unlock_entry(entry_ref);
}

References InvalidOid, pgstat_get_entry_ref_locked(), PGSTAT_KIND_REPLSLOT, pgstat_unlock_entry(), ReplicationSlotIndex(), REPLSLOT_ACC, PgStat_EntryRef::shared_stats, and PgStatShared_ReplSlot::stats.

Referenced by UpdateDecodingStats().

pgstat_report_stat()

long pgstat_report_stat

(

bool

force

)

Definition at line 575 of file pgstat.c.

{
    static TimestampTz pending_since = 0;
    static TimestampTz last_flush = 0;
    bool        partial_flush;
    TimestampTz now;
    bool        nowait;
 
    pgstat_assert_is_up();
    Assert(!IsTransactionOrTransactionBlock());
 
    /* "absorb" the forced flush even if there's nothing to flush */
    if (pgStatForceNextFlush)
    {
        force = true;
        pgStatForceNextFlush = false;
    }
 
    /* Don't expend a clock check if nothing to do */
    if (dlist_is_empty(&pgStatPending) &&
        !have_iostats &&
        !have_slrustats &&
        !pgstat_have_pending_wal())
    {
        Assert(pending_since == 0);
        return 0;
    }
 
    /*
     * There should never be stats to report once stats are shut down. Can't
     * assert that before the checks above, as there is an unconditional
     * pgstat_report_stat() call in pgstat_shutdown_hook() - which at least
     * the process that ran pgstat_before_server_shutdown() will still call.
     */
    Assert(!pgStatLocal.shmem->is_shutdown);
 
    now = GetCurrentTransactionStopTimestamp();
 
    if (!force)
    {
        if (pending_since > 0 &&
            TimestampDifferenceExceeds(pending_since, now, PGSTAT_MAX_INTERVAL))
        {
            /* don't keep pending updates longer than PGSTAT_MAX_INTERVAL */
            force = true;
        }
        else if (last_flush > 0 &&
                 !TimestampDifferenceExceeds(last_flush, now, PGSTAT_MIN_INTERVAL))
        {
            /* don't flush too frequently */
            if (pending_since == 0)
                pending_since = now;
 
            return PGSTAT_IDLE_INTERVAL;
        }
    }
 
    pgstat_update_dbstats(now);
 
    /* don't wait for lock acquisition when !force */
    nowait = !force;
 
    partial_flush = false;
 
    /* flush database / relation / function / ... stats */
    partial_flush |= pgstat_flush_pending_entries(nowait);
 
    /* flush IO stats */
    partial_flush |= pgstat_flush_io(nowait);
 
    /* flush wal stats */
    partial_flush |= pgstat_flush_wal(nowait);
 
    /* flush SLRU stats */
    partial_flush |= pgstat_slru_flush(nowait);
 
    last_flush = now;
 
    /*
     * If some of the pending stats could not be flushed due to lock
     * contention, let the caller know when to retry.
     */
    if (partial_flush)
    {
        /* force should have prevented us from getting here */
        Assert(!force);
 
        /* remember since when stats have been pending */
        if (pending_since == 0)
            pending_since = now;
 
        return PGSTAT_IDLE_INTERVAL;
    }
 
    pending_since = 0;
 
    return 0;
}

References Assert(), dlist_is_empty(), GetCurrentTransactionStopTimestamp(), have_iostats, have_slrustats, PgStat_ShmemControl::is_shutdown, IsTransactionOrTransactionBlock(), now(), pgstat_assert_is_up, pgstat_flush_io(), pgstat_flush_pending_entries(), pgstat_flush_wal(), pgstat_have_pending_wal(), PGSTAT_IDLE_INTERVAL, PGSTAT_MAX_INTERVAL, PGSTAT_MIN_INTERVAL, pgstat_slru_flush(), pgstat_update_dbstats(), pgStatForceNextFlush, pgStatLocal, pgStatPending, PgStat_LocalState::shmem, and TimestampDifferenceExceeds().

Referenced by AllTablesyncsReady(), apply_handle_commit_internal(), apply_handle_commit_prepared(), apply_handle_prepare(), apply_handle_rollback_prepared(), apply_handle_stream_prepare(), LogicalRepApplyLoop(), LogicalRepSyncTableStart(), pg_attribute_noreturn(), pgstat_before_server_shutdown(), pgstat_shutdown_hook(), PostgresMain(), process_syncing_tables_for_apply(), process_syncing_tables_for_sync(), and ProcessInterrupts().

pgstat_report_subscription_error()

void pgstat_report_subscription_error	(	Oid	subid,
		bool	is_apply_error
	)

Definition at line 27 of file pgstat_subscription.c.

{
    PgStat_EntryRef *entry_ref;
    PgStat_BackendSubEntry *pending;
 
    entry_ref = pgstat_prep_pending_entry(PGSTAT_KIND_SUBSCRIPTION,
                                          InvalidOid, subid, NULL);
    pending = entry_ref->pending;
 
    if (is_apply_error)
        pending->apply_error_count++;
    else
        pending->sync_error_count++;
}

References PgStat_BackendSubEntry::apply_error_count, InvalidOid, PgStat_EntryRef::pending, PGSTAT_KIND_SUBSCRIPTION, pgstat_prep_pending_entry(), and PgStat_BackendSubEntry::sync_error_count.

Referenced by DisableSubscriptionAndExit(), start_apply(), and start_table_sync().

pgstat_report_vacuum()

void pgstat_report_vacuum	(	Oid	tableoid,
		bool	shared,
		PgStat_Counter	livetuples,
		PgStat_Counter	deadtuples
	)

Definition at line 212 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Relation *shtabentry;
    PgStat_StatTabEntry *tabentry;
    Oid         dboid = (shared ? InvalidOid : MyDatabaseId);
    TimestampTz ts;
 
    if (!pgstat_track_counts)
        return;
 
    /* Store the data in the table's hash table entry. */
    ts = GetCurrentTimestamp();
 
    /* block acquiring lock for the same reason as pgstat_report_autovac() */
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION,
                                            dboid, tableoid, false);
 
    shtabentry = (PgStatShared_Relation *) entry_ref->shared_stats;
    tabentry = &shtabentry->stats;
 
    tabentry->live_tuples = livetuples;
    tabentry->dead_tuples = deadtuples;
 
    /*
     * It is quite possible that a non-aggressive VACUUM ended up skipping
     * various pages, however, we'll zero the insert counter here regardless.
     * It's currently used only to track when we need to perform an "insert"
     * autovacuum, which are mainly intended to freeze newly inserted tuples.
     * Zeroing this may just mean we'll not try to vacuum the table again
     * until enough tuples have been inserted to trigger another insert
     * autovacuum.  An anti-wraparound autovacuum will catch any persistent
     * stragglers.
     */
    tabentry->ins_since_vacuum = 0;
 
    if (IsAutoVacuumWorkerProcess())
    {
        tabentry->last_autovacuum_time = ts;
        tabentry->autovacuum_count++;
    }
    else
    {
        tabentry->last_vacuum_time = ts;
        tabentry->vacuum_count++;
    }
 
    pgstat_unlock_entry(entry_ref);
 
    /*
     * Flush IO statistics now. pgstat_report_stat() will flush IO stats,
     * however this will not be called until after an entire autovacuum cycle
     * is done -- which will likely vacuum many relations -- or until the
     * VACUUM command has processed all tables and committed.
     */
    pgstat_flush_io(false);
}

References PgStat_StatTabEntry::autovacuum_count, PgStat_StatTabEntry::dead_tuples, GetCurrentTimestamp(), if(), PgStat_StatTabEntry::ins_since_vacuum, InvalidOid, IsAutoVacuumWorkerProcess(), PgStat_StatTabEntry::last_autovacuum_time, PgStat_StatTabEntry::last_vacuum_time, PgStat_StatTabEntry::live_tuples, MyDatabaseId, pgstat_flush_io(), pgstat_get_entry_ref_locked(), PGSTAT_KIND_RELATION, pgstat_track_counts, pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, PgStatShared_Relation::stats, and PgStat_StatTabEntry::vacuum_count.

Referenced by heap_vacuum_rel().

pgstat_report_wal()

void pgstat_report_wal

(

bool

force

)

Definition at line 43 of file pgstat_wal.c.

{
    pgstat_flush_wal(force);
 
    pgstat_flush_io(force);
}

References pgstat_flush_io(), and pgstat_flush_wal().

Referenced by CheckpointerMain(), HandleCheckpointerInterrupts(), and WalWriterMain().

pgstat_reset()

void pgstat_reset	(	PgStat_Kind	kind,
		Oid	dboid,
		Oid	objoid
	)

Definition at line 719 of file pgstat.c.

{
    const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
    TimestampTz ts = GetCurrentTimestamp();
 
    /* not needed atm, and doesn't make sense with the current signature */
    Assert(!pgstat_get_kind_info(kind)->fixed_amount);
 
    /* reset the "single counter" */
    pgstat_reset_entry(kind, dboid, objoid, ts);
 
    if (!kind_info->accessed_across_databases)
        pgstat_reset_database_timestamp(dboid, ts);
}

References PgStat_KindInfo::accessed_across_databases, Assert(), GetCurrentTimestamp(), pgstat_get_kind_info(), pgstat_reset_database_timestamp(), and pgstat_reset_entry().

Referenced by pg_stat_reset_single_function_counters(), pg_stat_reset_single_table_counters(), pg_stat_reset_subscription_stats(), pgstat_create_transactional(), and pgstat_reset_replslot().

pgstat_reset_counters()

void pgstat_reset_counters

(

void

)

Definition at line 700 of file pgstat.c.

{
    TimestampTz ts = GetCurrentTimestamp();
 
    pgstat_reset_matching_entries(match_db_entries,
                                  ObjectIdGetDatum(MyDatabaseId),
                                  ts);
}

References GetCurrentTimestamp(), match_db_entries(), MyDatabaseId, ObjectIdGetDatum(), and pgstat_reset_matching_entries().

Referenced by pg_stat_reset().

pgstat_reset_of_kind()

void pgstat_reset_of_kind

(

PgStat_Kind

kind

)

Definition at line 741 of file pgstat.c.

{
    const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
    TimestampTz ts = GetCurrentTimestamp();
 
    if (kind_info->fixed_amount)
        kind_info->reset_all_cb(ts);
    else
        pgstat_reset_entries_of_kind(kind, ts);
}

References PgStat_KindInfo::fixed_amount, GetCurrentTimestamp(), pgstat_get_kind_info(), pgstat_reset_entries_of_kind(), and PgStat_KindInfo::reset_all_cb.

Referenced by pg_stat_reset_replication_slot(), pg_stat_reset_shared(), pg_stat_reset_slru(), and pg_stat_reset_subscription_stats().

pgstat_reset_replslot()

void pgstat_reset_replslot

(

const char *

name

)

Definition at line 43 of file pgstat_replslot.c.

{
    ReplicationSlot *slot;
 
    Assert(name != NULL);
 
    /* Check if the slot exits with the given name. */
    slot = SearchNamedReplicationSlot(name, true);
 
    if (!slot)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("replication slot \"%s\" does not exist",
                        name)));
 
    /*
     * Nothing to do for physical slots as we collect stats only for logical
     * slots.
     */
    if (SlotIsPhysical(slot))
        return;
 
    /* reset this one entry */
    pgstat_reset(PGSTAT_KIND_REPLSLOT, InvalidOid,
                 ReplicationSlotIndex(slot));
}

References Assert(), ereport, errcode(), errmsg(), ERROR, InvalidOid, name, PGSTAT_KIND_REPLSLOT, pgstat_reset(), ReplicationSlotIndex(), SearchNamedReplicationSlot(), and SlotIsPhysical.

Referenced by pg_stat_reset_replication_slot().

pgstat_reset_slru()

void pgstat_reset_slru

(

const char *

name

)

Definition at line 45 of file pgstat_slru.c.

{
    TimestampTz ts = GetCurrentTimestamp();
 
    Assert(name != NULL);
 
    pgstat_reset_slru_counter_internal(pgstat_get_slru_index(name), ts);
}

References Assert(), GetCurrentTimestamp(), name, pgstat_get_slru_index(), and pgstat_reset_slru_counter_internal().

Referenced by pg_stat_reset_slru().

pgstat_restore_stats()

void pgstat_restore_stats

(

void

)

Definition at line 403 of file pgstat.c.

{
    pgstat_read_statsfile();
}

References pgstat_read_statsfile().

Referenced by StartupXLOG().

pgstat_tracks_io_bktype()

bool pgstat_tracks_io_bktype

(

BackendType

bktype

)

Definition at line 231 of file pgstat_io.c.

{
    /*
     * List every type so that new backend types trigger a warning about
     * needing to adjust this switch.
     */
    switch (bktype)
    {
        case B_INVALID:
        case B_ARCHIVER:
        case B_LOGGER:
        case B_WAL_RECEIVER:
        case B_WAL_WRITER:
            return false;
 
        case B_AUTOVAC_LAUNCHER:
        case B_AUTOVAC_WORKER:
        case B_BACKEND:
        case B_BG_WORKER:
        case B_BG_WRITER:
        case B_CHECKPOINTER:
        case B_STANDALONE_BACKEND:
        case B_STARTUP:
        case B_WAL_SENDER:
            return true;
    }
 
    return false;
}

References B_ARCHIVER, B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_INVALID, B_LOGGER, B_STANDALONE_BACKEND, B_STARTUP, B_WAL_RECEIVER, B_WAL_SENDER, and B_WAL_WRITER.

Referenced by pg_stat_get_io(), pgstat_bktype_io_stats_valid(), and pgstat_tracks_io_object().

pgstat_tracks_io_object()

bool pgstat_tracks_io_object	(	BackendType	bktype,
		IOObject	io_object,
		IOContext	io_context
	)

Definition at line 269 of file pgstat_io.c.

{
    bool        no_temp_rel;
 
    /*
     * Some BackendTypes should never track IO statistics.
     */
    if (!pgstat_tracks_io_bktype(bktype))
        return false;
 
    /*
     * Currently, IO on temporary relations can only occur in the
     * IOCONTEXT_NORMAL IOContext.
     */
    if (io_context != IOCONTEXT_NORMAL &&
        io_object == IOOBJECT_TEMP_RELATION)
        return false;
 
    /*
     * In core Postgres, only regular backends and WAL Sender processes
     * executing queries will use local buffers and operate on temporary
     * relations. Parallel workers will not use local buffers (see
     * InitLocalBuffers()); however, extensions leveraging background workers
     * have no such limitation, so track IO on IOOBJECT_TEMP_RELATION for
     * BackendType B_BG_WORKER.
     */
    no_temp_rel = bktype == B_AUTOVAC_LAUNCHER || bktype == B_BG_WRITER ||
        bktype == B_CHECKPOINTER || bktype == B_AUTOVAC_WORKER ||
        bktype == B_STANDALONE_BACKEND || bktype == B_STARTUP;
 
    if (no_temp_rel && io_context == IOCONTEXT_NORMAL &&
        io_object == IOOBJECT_TEMP_RELATION)
        return false;
 
    /*
     * Some BackendTypes do not currently perform any IO in certain
     * IOContexts, and, while it may not be inherently incorrect for them to
     * do so, excluding those rows from the view makes the view easier to use.
     */
    if ((bktype == B_CHECKPOINTER || bktype == B_BG_WRITER) &&
        (io_context == IOCONTEXT_BULKREAD ||
         io_context == IOCONTEXT_BULKWRITE ||
         io_context == IOCONTEXT_VACUUM))
        return false;
 
    if (bktype == B_AUTOVAC_LAUNCHER && io_context == IOCONTEXT_VACUUM)
        return false;
 
    if ((bktype == B_AUTOVAC_WORKER || bktype == B_AUTOVAC_LAUNCHER) &&
        io_context == IOCONTEXT_BULKWRITE)
        return false;
 
    return true;
}

References B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_STANDALONE_BACKEND, B_STARTUP, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, IOOBJECT_TEMP_RELATION, and pgstat_tracks_io_bktype().

Referenced by pg_stat_get_io(), and pgstat_tracks_io_op().

pgstat_tracks_io_op()

bool pgstat_tracks_io_op	(	BackendType	bktype,
		IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op
	)

Definition at line 334 of file pgstat_io.c.

{
    bool        strategy_io_context;
 
    /* if (io_context, io_object) will never collect stats, we're done */
    if (!pgstat_tracks_io_object(bktype, io_object, io_context))
        return false;
 
    /*
     * Some BackendTypes will not do certain IOOps.
     */
    if ((bktype == B_BG_WRITER || bktype == B_CHECKPOINTER) &&
        (io_op == IOOP_READ || io_op == IOOP_EVICT || io_op == IOOP_HIT))
        return false;
 
    if ((bktype == B_AUTOVAC_LAUNCHER || bktype == B_BG_WRITER ||
         bktype == B_CHECKPOINTER) && io_op == IOOP_EXTEND)
        return false;
 
    /*
     * Some IOOps are not valid in certain IOContexts and some IOOps are only
     * valid in certain contexts.
     */
    if (io_context == IOCONTEXT_BULKREAD && io_op == IOOP_EXTEND)
        return false;
 
    strategy_io_context = io_context == IOCONTEXT_BULKREAD ||
        io_context == IOCONTEXT_BULKWRITE || io_context == IOCONTEXT_VACUUM;
 
    /*
     * IOOP_REUSE is only relevant when a BufferAccessStrategy is in use.
     */
    if (!strategy_io_context && io_op == IOOP_REUSE)
        return false;
 
    /*
     * IOOP_FSYNC IOOps done by a backend using a BufferAccessStrategy are
     * counted in the IOCONTEXT_NORMAL IOContext. See comment in
     * register_dirty_segment() for more details.
     */
    if (strategy_io_context && io_op == IOOP_FSYNC)
        return false;
 
    /*
     * Temporary tables are not logged and thus do not require fsync'ing.
     */
    if (io_context == IOCONTEXT_NORMAL &&
        io_object == IOOBJECT_TEMP_RELATION && io_op == IOOP_FSYNC)
        return false;
 
    return true;
}

References B_AUTOVAC_LAUNCHER, B_BG_WRITER, B_CHECKPOINTER, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, IOOBJECT_TEMP_RELATION, IOOP_EVICT, IOOP_EXTEND, IOOP_FSYNC, IOOP_HIT, IOOP_READ, IOOP_REUSE, and pgstat_tracks_io_object().

Referenced by pg_stat_get_io(), pgstat_bktype_io_stats_valid(), and pgstat_count_io_op().

pgstat_twophase_postabort()

void pgstat_twophase_postabort	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 738 of file pgstat_relation.c.

{
    TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
    PgStat_TableStatus *pgstat_info;
 
    /* Find or create a tabstat entry for the rel */
    pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared);
 
    /* Same math as in AtEOXact_PgStat, abort case */
    if (rec->truncdropped)
    {
        rec->tuples_inserted = rec->inserted_pre_truncdrop;
        rec->tuples_updated = rec->updated_pre_truncdrop;
        rec->tuples_deleted = rec->deleted_pre_truncdrop;
    }
    pgstat_info->counts.tuples_inserted += rec->tuples_inserted;
    pgstat_info->counts.tuples_updated += rec->tuples_updated;
    pgstat_info->counts.tuples_deleted += rec->tuples_deleted;
    pgstat_info->counts.delta_dead_tuples +=
        rec->tuples_inserted + rec->tuples_updated;
}

References PgStat_TableStatus::counts, TwoPhasePgStatRecord::deleted_pre_truncdrop, PgStat_TableCounts::delta_dead_tuples, TwoPhasePgStatRecord::id, TwoPhasePgStatRecord::inserted_pre_truncdrop, pgstat_prep_relation_pending(), TwoPhasePgStatRecord::shared, TwoPhasePgStatRecord::truncdropped, TwoPhasePgStatRecord::tuples_deleted, PgStat_TableCounts::tuples_deleted, TwoPhasePgStatRecord::tuples_inserted, PgStat_TableCounts::tuples_inserted, TwoPhasePgStatRecord::tuples_updated, PgStat_TableCounts::tuples_updated, and TwoPhasePgStatRecord::updated_pre_truncdrop.

pgstat_twophase_postcommit()

void pgstat_twophase_postcommit	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 702 of file pgstat_relation.c.

{
    TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
    PgStat_TableStatus *pgstat_info;
 
    /* Find or create a tabstat entry for the rel */
    pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared);
 
    /* Same math as in AtEOXact_PgStat, commit case */
    pgstat_info->counts.tuples_inserted += rec->tuples_inserted;
    pgstat_info->counts.tuples_updated += rec->tuples_updated;
    pgstat_info->counts.tuples_deleted += rec->tuples_deleted;
    pgstat_info->counts.truncdropped = rec->truncdropped;
    if (rec->truncdropped)
    {
        /* forget live/dead stats seen by backend thus far */
        pgstat_info->counts.delta_live_tuples = 0;
        pgstat_info->counts.delta_dead_tuples = 0;
    }
    pgstat_info->counts.delta_live_tuples +=
        rec->tuples_inserted - rec->tuples_deleted;
    pgstat_info->counts.delta_dead_tuples +=
        rec->tuples_updated + rec->tuples_deleted;
    pgstat_info->counts.changed_tuples +=
        rec->tuples_inserted + rec->tuples_updated +
        rec->tuples_deleted;
}

References PgStat_TableCounts::changed_tuples, PgStat_TableStatus::counts, PgStat_TableCounts::delta_dead_tuples, PgStat_TableCounts::delta_live_tuples, TwoPhasePgStatRecord::id, pgstat_prep_relation_pending(), TwoPhasePgStatRecord::shared, TwoPhasePgStatRecord::truncdropped, PgStat_TableCounts::truncdropped, TwoPhasePgStatRecord::tuples_deleted, PgStat_TableCounts::tuples_deleted, TwoPhasePgStatRecord::tuples_inserted, PgStat_TableCounts::tuples_inserted, TwoPhasePgStatRecord::tuples_updated, and PgStat_TableCounts::tuples_updated.

pgstat_unlink_relation()

void pgstat_unlink_relation

(

Relation

rel

)

Definition at line 154 of file pgstat_relation.c.

{
    /* remove the link to stats info if any */
    if (rel->pgstat_info == NULL)
        return;
 
    /* link sanity check */
    Assert(rel->pgstat_info->relation == rel);
    rel->pgstat_info->relation = NULL;
    rel->pgstat_info = NULL;
}

References Assert(), RelationData::pgstat_info, and PgStat_TableStatus::relation.

Referenced by pgstat_init_relation(), pgstat_relation_delete_pending_cb(), and RelationDestroyRelation().

pgstat_update_heap_dead_tuples()

void pgstat_update_heap_dead_tuples	(	Relation	rel,
		int	delta
	)

Definition at line 440 of file pgstat_relation.c.

{
    if (pgstat_should_count_relation(rel))
    {
        PgStat_TableStatus *pgstat_info = rel->pgstat_info;
 
        pgstat_info->counts.delta_dead_tuples -= delta;
    }
}

References PgStat_TableStatus::counts, PgStat_TableCounts::delta_dead_tuples, RelationData::pgstat_info, and pgstat_should_count_relation.

Referenced by heap_page_prune_opt().

PostPrepare_PgStat()

void PostPrepare_PgStat

(

void

)

Definition at line 210 of file pgstat_xact.c.

{
    PgStat_SubXactStatus *xact_state;
 
    /*
     * We don't bother to free any of the transactional state, since it's all
     * in TopTransactionContext and will go away anyway.
     */
    xact_state = pgStatXactStack;
    if (xact_state != NULL)
    {
        Assert(xact_state->nest_level == 1);
        Assert(xact_state->prev == NULL);
 
        PostPrepare_PgStat_Relations(xact_state);
    }
    pgStatXactStack = NULL;
 
    /* Make sure any stats snapshot is thrown away */
    pgstat_clear_snapshot();
}

References Assert(), PgStat_SubXactStatus::nest_level, pgstat_clear_snapshot(), pgStatXactStack, PostPrepare_PgStat_Relations(), and PgStat_SubXactStatus::prev.

Referenced by PrepareTransaction().

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);
    }
}

References PgStat_ShmemControl::archiver, Assert(), BACKEND_NUM_TYPES, PgStat_ShmemControl::bgwriter, PgStat_ShmemControl::checkpointer, dsa_create_in_place(), dsa_detach(), dsa_pin(), dsa_set_size_limit(), dsh_params, dshash_create(), dshash_detach(), dshash_get_hash_table_handle(), PgStat_ShmemControl::gc_request_count, PgStat_ShmemControl::hash_handle, i, PgStat_ShmemControl::io, IsUnderPostmaster, PgStatShared_Archiver::lock, PgStatShared_BgWriter::lock, PgStatShared_Checkpointer::lock, PgStatShared_SLRU::lock, PgStatShared_Wal::lock, PgStatShared_IO::locks, LWLockInitialize(), LWTRANCHE_PGSTATS_DATA, LWTRANCHE_PGSTATS_DSA, MAXALIGN, pg_atomic_init_u64(), pgstat_dsa_init_size(), pgStatLocal, PgStat_ShmemControl::raw_dsa_area, PgStat_LocalState::shmem, ShmemInitStruct(), PgStat_ShmemControl::slru, StatsShmemSize(), and PgStat_ShmemControl::wal.

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

PendingBgWriterStats

PGDLLIMPORT PgStat_BgWriterStats PendingBgWriterStats

extern

Definition at line 23 of file pgstat_bgwriter.c.

Referenced by BgBufferSync(), and pgstat_report_bgwriter().

PendingCheckpointerStats

PGDLLIMPORT PgStat_CheckpointerStats PendingCheckpointerStats

extern

Definition at line 23 of file pgstat_checkpointer.c.

Referenced by AbsorbSyncRequests(), BufferSync(), CheckpointerMain(), HandleCheckpointerInterrupts(), LogCheckpointEnd(), and pgstat_report_checkpointer().

PendingWalStats

PGDLLIMPORT PgStat_PendingWalStats PendingWalStats

extern

Definition at line 24 of file pgstat_wal.c.

Referenced by AdvanceXLInsertBuffer(), issue_xlog_fsync(), pgstat_flush_wal(), pgstat_have_pending_wal(), and XLogWrite().

pgstat_fetch_consistency

PGDLLIMPORT int pgstat_fetch_consistency

extern

Definition at line 188 of file pgstat.c.

Referenced by pgstat_build_snapshot(), pgstat_build_snapshot_fixed(), pgstat_fetch_entry(), pgstat_prep_snapshot(), pgstat_snapshot_fixed(), and pgstat_write_statsfile().

pgstat_track_counts

PGDLLIMPORT bool pgstat_track_counts

extern

Definition at line 187 of file pgstat.c.

Referenced by autovac_init(), AutoVacuumingActive(), pgstat_init_relation(), pgstat_report_analyze(), pgstat_report_checksum_failures_in_db(), pgstat_report_deadlock(), pgstat_report_recovery_conflict(), pgstat_report_tempfile(), and pgstat_report_vacuum().

pgstat_track_functions

PGDLLIMPORT int pgstat_track_functions

extern

Definition at line 30 of file pgstat_function.c.

pgStatActiveTime

PGDLLIMPORT PgStat_Counter pgStatActiveTime

extern

Definition at line 30 of file pgstat_database.c.

Referenced by pgstat_update_dbstats().

pgStatBlockReadTime

PGDLLIMPORT PgStat_Counter pgStatBlockReadTime

extern

Definition at line 28 of file pgstat_database.c.

Referenced by do_analyze_rel(), heap_vacuum_rel(), and pgstat_update_dbstats().

pgStatBlockWriteTime

PGDLLIMPORT PgStat_Counter pgStatBlockWriteTime

extern

Definition at line 29 of file pgstat_database.c.

Referenced by do_analyze_rel(), heap_vacuum_rel(), and pgstat_update_dbstats().

pgStatSessionEndCause

PGDLLIMPORT SessionEndType pgStatSessionEndCause

extern

Definition at line 32 of file pgstat_database.c.

Referenced by die(), errfinish(), pgstat_report_disconnect(), and PostgresMain().

pgStatTransactionIdleTime

PGDLLIMPORT PgStat_Counter pgStatTransactionIdleTime

extern

Definition at line 31 of file pgstat_database.c.

Referenced by pgstat_update_dbstats().