pgstat.h File Reference

#include "datatype/timestamp.h"
#include "portability/instr_time.h"
#include "postmaster/pgarch.h"
#include "replication/conflict.h"
#include "storage/locktag.h"
#include "utils/backend_progress.h"
#include "utils/backend_status.h"
#include "utils/pgstat_kind.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_PendingIO
struct	PgStat_IO
struct	PgStat_LockEntry
struct	PgStat_PendingLock
struct	PgStat_Lock
struct	PgStat_StatDBEntry
struct	PgStat_StatFuncEntry
struct	PgStat_StatReplSlotEntry
struct	PgStat_SLRUStats
struct	PgStat_StatSubEntry
struct	PgStat_StatTabEntry
struct	PgStat_WalCounters
struct	PgStat_WalStats
struct	PgStat_Backend
struct	PgStat_BackendPending

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_FILE_FORMAT_ID   0x01A5BCBC
#define	IOOBJECT_NUM_TYPES   (IOOBJECT_WAL + 1)
#define	IOCONTEXT_NUM_TYPES   (IOCONTEXT_VACUUM + 1)
#define	IOOP_NUM_TYPES   (IOOP_WRITE + 1)
#define	pgstat_is_ioop_tracked_in_bytes(io_op)
#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 struct FullTransactionId	FullTransactionId
typedef struct RelationData *	Relation
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_PendingIO	PgStat_PendingIO
typedef struct PgStat_IO	PgStat_IO
typedef struct PgStat_LockEntry	PgStat_LockEntry
typedef struct PgStat_PendingLock	PgStat_PendingLock
typedef struct PgStat_Lock	PgStat_Lock
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_WalCounters	PgStat_WalCounters
typedef struct PgStat_WalStats	PgStat_WalStats
typedef struct PgStat_Backend	PgStat_Backend
typedef struct PgStat_BackendPending	PgStat_BackendPending

Enumerations
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 , IOOBJECT_WAL }
enum	IOContext {   IOCONTEXT_BULKREAD , IOCONTEXT_BULKWRITE , IOCONTEXT_INIT , IOCONTEXT_NORMAL ,   IOCONTEXT_VACUUM }
enum	IOOp {   IOOP_EVICT , IOOP_FSYNC , IOOP_HIT , IOOP_REUSE ,   IOOP_WRITEBACK , IOOP_EXTEND , IOOP_READ , IOOP_WRITE }

Functions
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, uint64 objid)
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, uint64 objid)
void	pgstat_report_archiver (const char *xlog, bool failed)
PgStat_ArchiverStats *	pgstat_fetch_stat_archiver (void)
void	pgstat_count_backend_io_op_time (IOObject io_object, IOContext io_context, IOOp io_op, instr_time io_time)
void	pgstat_count_backend_io_op (IOObject io_object, IOContext io_context, IOOp io_op, uint32 cnt, uint64 bytes)
PgStat_Backend *	pgstat_fetch_stat_backend (ProcNumber procNumber)
PgStat_Backend *	pgstat_fetch_stat_backend_by_pid (int pid, BackendType *bktype)
bool	pgstat_tracks_backend_bktype (BackendType bktype)
void	pgstat_create_backend (ProcNumber procnum)
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 *backend_io, BackendType bktype)
void	pgstat_count_io_op (IOObject io_object, IOContext io_context, IOOp io_op, uint32 cnt, uint64 bytes)
instr_time	pgstat_prepare_io_time (bool track_io_guc)
void	pgstat_count_io_op_time (IOObject io_object, IOContext io_context, IOOp io_op, instr_time start_time, uint32 cnt, uint64 bytes)
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_lock_flush (bool nowait)
void	pgstat_count_lock_fastpath_exceeded (uint8 locktag_type)
void	pgstat_count_lock_waits (uint8 locktag_type, long msecs)
PgStat_Lock *	pgstat_fetch_stat_lock (void)
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_prepare_report_checksum_failure (Oid dboid)
void	pgstat_report_checksum_failures_in_db (Oid dboid, int failurecount)
void	pgstat_report_connect (Oid dboid)
void	pgstat_update_parallel_workers_stats (PgStat_Counter workers_to_launch, PgStat_Counter workers_launched)
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 (Relation rel, PgStat_Counter livetuples, PgStat_Counter deadtuples, TimestampTz starttime)
void	pgstat_report_analyze (Relation rel, PgStat_Counter livetuples, PgStat_Counter deadtuples, bool resetcounter, TimestampTz starttime)
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 (FullTransactionId fxid, uint16 info, void *recdata, uint32 len)
void	pgstat_twophase_postabort (FullTransactionId fxid, 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, bool *may_free)
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_report_replslotsync (struct ReplicationSlot *slot)
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_blocks_zeroed (int slru_idx)
void	pgstat_count_slru_blocks_hit (int slru_idx)
void	pgstat_count_slru_blocks_read (int slru_idx)
void	pgstat_count_slru_blocks_written (int slru_idx)
void	pgstat_count_slru_blocks_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)
void	pgstat_report_subscription_conflict (Oid subid, ConflictType type)
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

Macro Definition Documentation

IOCONTEXT_NUM_TYPES

#define IOCONTEXT_NUM_TYPES   (IOCONTEXT_VACUUM + 1)

Definition at line 297 of file pgstat.h.

IOOBJECT_NUM_TYPES

#define IOOBJECT_NUM_TYPES   (IOOBJECT_WAL + 1)

Definition at line 286 of file pgstat.h.

IOOP_NUM_TYPES

#define IOOP_NUM_TYPES   (IOOP_WRITE + 1)

Definition at line 323 of file pgstat.h.

PG_STAT_TMP_DIR

#define PG_STAT_TMP_DIR   "pg_stat_tmp"

Definition at line 40 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 747 of file pgstat.h.

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

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 742 of file pgstat.h.

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

pgstat_count_buffer_read_time

#define pgstat_count_buffer_read_time

(

n

)

(pgStatBlockReadTime += (n))

Definition at line 658 of file pgstat.h.

pgstat_count_buffer_write_time

#define pgstat_count_buffer_write_time

(

n

)

(pgStatBlockWriteTime += (n))

Definition at line 660 of file pgstat.h.

pgstat_count_conn_active_time

#define pgstat_count_conn_active_time

(

n

)

(pgStatActiveTime += (n))

Definition at line 662 of file pgstat.h.

pgstat_count_conn_txn_idle_time

#define pgstat_count_conn_txn_idle_time

(

n

)

(pgStatTransactionIdleTime += (n))

Definition at line 664 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 727 of file pgstat.h.

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

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 722 of file pgstat.h.

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

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 717 of file pgstat.h.

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

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 732 of file pgstat.h.

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

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 737 of file pgstat.h.

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

PGSTAT_FILE_FORMAT_ID

#define PGSTAT_FILE_FORMAT_ID   0x01A5BCBC

Definition at line 221 of file pgstat.h.

pgstat_is_ioop_tracked_in_bytes

#define pgstat_is_ioop_tracked_in_bytes

(

io_op

)

Value:

    (((unsigned int) (io_op)) < IOOP_NUM_TYPES && \
     ((unsigned int) (io_op)) >= IOOP_EXTEND)

Definition at line 325 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 711 of file pgstat.h.

                                               :                    \
     ((rel)->pgstat_enabled ? pgstat_assoc_relation(rel), true : false))

PGSTAT_STAT_PERMANENT_DIRECTORY

#define PGSTAT_STAT_PERMANENT_DIRECTORY   "pg_stat"

Definition at line 35 of file pgstat.h.

PGSTAT_STAT_PERMANENT_FILENAME

#define PGSTAT_STAT_PERMANENT_FILENAME   "pg_stat/pgstat.stat"

Definition at line 36 of file pgstat.h.

PGSTAT_STAT_PERMANENT_TMPFILE

#define PGSTAT_STAT_PERMANENT_TMPFILE   "pg_stat/pgstat.tmp"

Definition at line 37 of file pgstat.h.

Typedef Documentation

FullTransactionId

typedef struct FullTransactionId FullTransactionId

Definition at line 25 of file pgstat.h.

IOContext

typedef enum IOContext IOContext

IOObject

typedef enum IOObject IOObject

IOOp

typedef enum IOOp IOOp

PgStat_ArchiverStats

typedef struct PgStat_ArchiverStats PgStat_ArchiverStats

PgStat_Backend

typedef struct PgStat_Backend PgStat_Backend

PgStat_BackendPending

typedef struct PgStat_BackendPending PgStat_BackendPending

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 71 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_Lock

typedef struct PgStat_Lock PgStat_Lock

PgStat_LockEntry

typedef struct PgStat_LockEntry PgStat_LockEntry

PgStat_PendingIO

typedef struct PgStat_PendingIO PgStat_PendingIO

PgStat_PendingLock

typedef struct PgStat_PendingLock PgStat_PendingLock

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_WalCounters

typedef struct PgStat_WalCounters PgStat_WalCounters

PgStat_WalStats

typedef struct PgStat_WalStats PgStat_WalStats

Relation

typedef struct RelationData* Relation

Definition at line 28 of file pgstat.h.

SessionEndType

typedef enum SessionEndType SessionEndType

TrackFunctionsLevel

typedef enum TrackFunctionsLevel TrackFunctionsLevel

Enumeration Type Documentation

IOContext

enum IOContext

Enumerator
IOCONTEXT_BULKREAD
IOCONTEXT_BULKWRITE
IOCONTEXT_INIT
IOCONTEXT_NORMAL
IOCONTEXT_VACUUM

Definition at line 288 of file pgstat.h.

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

IOObject

enum IOObject

Enumerator
IOOBJECT_RELATION
IOOBJECT_TEMP_RELATION
IOOBJECT_WAL

Definition at line 279 of file pgstat.h.

{
    IOOBJECT_RELATION,
    IOOBJECT_TEMP_RELATION,
    IOOBJECT_WAL,
} IOObject;

IOOp

enum IOOp

Enumerator
IOOP_EVICT
IOOP_FSYNC
IOOP_HIT
IOOP_REUSE
IOOP_WRITEBACK
IOOP_EXTEND
IOOP_READ
IOOP_WRITE

Definition at line 308 of file pgstat.h.

{
    /* IOs not tracked in bytes */
    IOOP_EVICT,
    IOOP_FSYNC,
    IOOP_HIT,
    IOOP_REUSE,
    IOOP_WRITEBACK,
 
    /* IOs tracked in bytes */
    IOOP_EXTEND,
    IOOP_READ,
    IOOP_WRITE,
} IOOp;

PgStat_FetchConsistency

enum PgStat_FetchConsistency

Enumerator
PGSTAT_FETCH_CONSISTENCY_NONE
PGSTAT_FETCH_CONSISTENCY_CACHE
PGSTAT_FETCH_CONSISTENCY_SNAPSHOT

Definition at line 50 of file pgstat.h.

{
    PGSTAT_FETCH_CONSISTENCY_NONE,
    PGSTAT_FETCH_CONSISTENCY_CACHE,
    PGSTAT_FETCH_CONSISTENCY_SNAPSHOT,
} PgStat_FetchConsistency;

SessionEndType

enum SessionEndType

Enumerator
DISCONNECT_NOT_YET
DISCONNECT_NORMAL
DISCONNECT_CLIENT_EOF
DISCONNECT_FATAL
DISCONNECT_KILLED

Definition at line 58 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 43 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  )

extern

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(), fb(), PgStat_SubXactStatus::nest_level, pfree(), pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

AtEOXact_PgStat()

void AtEOXact_PgStat ( bool  isCommit, bool  parallel  )

extern

Definition at line 40 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(), fb(), PgStat_SubXactStatus::nest_level, pgstat_clear_snapshot(), pgStatXactStack, and PgStat_SubXactStatus::prev.

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

AtPrepare_PgStat()

void AtPrepare_PgStat ( void  )

extern

Definition at line 191 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(), fb(), PgStat_SubXactStatus::nest_level, pgStatXactStack, and PgStat_SubXactStatus::prev.

Referenced by PrepareTransaction().

find_funcstat_entry()

PgStat_FunctionCounts * find_funcstat_entry ( Oid  func_id )

extern

Definition at line 229 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 fb(), 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 )

extern

Definition at line 502 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
    PgStat_TableXactStatus *trans;
    PgStat_TableStatus *tabentry = NULL;
    PgStat_TableStatus *tablestatus = NULL;
 
    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 tablestatus;
    }
 
    tabentry = (PgStat_TableStatus *) entry_ref->pending;
    tablestatus = palloc_object(PgStat_TableStatus);
    *tablestatus = *tabentry;
 
    /*
     * Reset tablestatus->trans in the copy of PgStat_TableStatus as it may
     * point to a shared memory area.  Its data is saved below, so removing it
     * does not matter.
     */
    tablestatus->trans = NULL;
 
    /*
     * Live subtransaction counts are not included yet.  This is not a hot
     * code path so reconcile tuples_inserted, tuples_updated and
     * tuples_deleted even if the caller may not be interested in this data.
     */
    for (trans = tabentry->trans; trans != NULL; trans = trans->upper)
    {
        tablestatus->counts.tuples_inserted += trans->tuples_inserted;
        tablestatus->counts.tuples_updated += trans->tuples_updated;
        tablestatus->counts.tuples_deleted += trans->tuples_deleted;
    }
 
    return tablestatus;
}

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

pgstat_acquire_replslot()

void pgstat_acquire_replslot ( struct ReplicationSlot *  slot )

extern

Definition at line 176 of file pgstat_replslot.c.

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

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

Referenced by ReplicationSlotAcquire().

pgstat_assoc_relation()

void pgstat_assoc_relation ( Relation  rel )

extern

Definition at line 132 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, fb(), 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  )

extern

Definition at line 590 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, fb(), 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 *  backend_io, BackendType  bktype  )

extern

Definition at line 37 of file pgstat_io.c.

{
    for (int io_object = 0; io_object < IOOBJECT_NUM_TYPES; io_object++)
    {
        for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++)
        {
            for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++)
            {
                /* we do track it */
                if (pgstat_tracks_io_op(bktype, io_object, io_context, io_op))
                {
                    /* ensure that if IO times are non-zero, counts are > 0 */
                    if (backend_io->times[io_object][io_context][io_op] != 0 &&
                        backend_io->counts[io_object][io_context][io_op] <= 0)
                        return false;
 
                    continue;
                }
 
                /* we don't track it, and it is not 0 */
                if (backend_io->counts[io_object][io_context][io_op] != 0)
                    return false;
            }
        }
    }
 
    return true;
}

References fb(), IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, and pgstat_tracks_io_op().

Referenced by pg_stat_get_backend_io(), pg_stat_get_io(), and pgstat_io_flush_cb().

pgstat_clear_snapshot()

void pgstat_clear_snapshot ( void  )

extern

Definition at line 930 of file pgstat.c.

{
    pgstat_assert_is_up();
 
    memset(&pgStatLocal.snapshot.fixed_valid, 0,
           sizeof(pgStatLocal.snapshot.fixed_valid));
    memset(&pgStatLocal.snapshot.custom_valid, 0,
           sizeof(pgStatLocal.snapshot.custom_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();
 
    /* Reset this flag, as it may be possible that a cleanup was forced. */
    force_stats_snapshot_clear = false;

References PgStat_Snapshot::context, PgStat_Snapshot::custom_valid, fb(), PgStat_Snapshot::fixed_valid, force_stats_snapshot_clear, 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(), pgstat_get_stat_snapshot_timestamp(), pgstat_prep_snapshot(), pgstat_snapshot_fixed(), and PostPrepare_PgStat().

pgstat_copy_relation_stats()

void pgstat_copy_relation_stats ( Relation  dst, Relation  src  )

extern

Definition at line 57 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),
                                              NULL);
    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 fb(), InvalidOid, MyDatabaseId, pgstat_fetch_stat_tabentry_ext(), pgstat_get_entry_ref_locked(), PGSTAT_KIND_RELATION, pgstat_unlock_entry(), RelationData::rd_rel, RelationGetRelid, and PgStat_EntryRef::shared_stats.

Referenced by index_concurrently_swap().

pgstat_count_backend_io_op()

void pgstat_count_backend_io_op ( IOObject  io_object, IOContext  io_context, IOOp  io_op, uint32  cnt, uint64  bytes  )

extern

Definition at line 74 of file pgstat_backend.c.

{
    if (!pgstat_tracks_backend_bktype(MyBackendType))
        return;
 
    Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
 
    PendingBackendStats.pending_io.counts[io_object][io_context][io_op] += cnt;
    PendingBackendStats.pending_io.bytes[io_object][io_context][io_op] += bytes;
 
    backend_has_iostats = true;
    pgstat_report_fixed = true;
}

References Assert, backend_has_iostats, PgStat_PendingIO::bytes, PgStat_PendingIO::counts, fb(), MyBackendType, PgStat_BackendPending::pending_io, PendingBackendStats, pgstat_report_fixed, pgstat_tracks_backend_bktype(), and pgstat_tracks_io_op().

Referenced by pgstat_count_io_op().

pgstat_count_backend_io_op_time()

void pgstat_count_backend_io_op_time ( IOObject  io_object, IOContext  io_context, IOOp  io_op, instr_time  io_time  )

extern

Definition at line 56 of file pgstat_backend.c.

{
    Assert(track_io_timing || track_wal_io_timing);
 
    if (!pgstat_tracks_backend_bktype(MyBackendType))
        return;
 
    Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
 
    INSTR_TIME_ADD(PendingBackendStats.pending_io.pending_times[io_object][io_context][io_op],
                   io_time);
 
    backend_has_iostats = true;
    pgstat_report_fixed = true;
}

References Assert, backend_has_iostats, fb(), INSTR_TIME_ADD, MyBackendType, PgStat_BackendPending::pending_io, PgStat_PendingIO::pending_times, PendingBackendStats, pgstat_report_fixed, pgstat_tracks_backend_bktype(), pgstat_tracks_io_op(), track_io_timing, and track_wal_io_timing.

Referenced by pgstat_count_io_op_time().

pgstat_count_heap_delete()

void pgstat_count_heap_delete ( Relation  rel )

extern

Definition at line 415 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  )

extern

Definition at line 374 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 heap_insert(), heap_multi_insert(), and RefreshMatViewByOid().

pgstat_count_heap_update()

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

extern

Definition at line 389 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(), fb(), 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, uint32  cnt, uint64  bytes  )

extern

Definition at line 68 of file pgstat_io.c.

{
    Assert((unsigned int) io_object < IOOBJECT_NUM_TYPES);
    Assert((unsigned int) io_context < IOCONTEXT_NUM_TYPES);
    Assert(pgstat_is_ioop_tracked_in_bytes(io_op) || bytes == 0);
    Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
 
    PendingIOStats.counts[io_object][io_context][io_op] += cnt;
    PendingIOStats.bytes[io_object][io_context][io_op] += bytes;
 
    /* Add the per-backend counts */
    pgstat_count_backend_io_op(io_object, io_context, io_op, cnt, bytes);
 
    have_iostats = true;
    pgstat_report_fixed = true;
}

References Assert, PgStat_PendingIO::bytes, PgStat_PendingIO::counts, fb(), have_iostats, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, MyBackendType, PendingIOStats, pgstat_count_backend_io_op(), pgstat_is_ioop_tracked_in_bytes, pgstat_report_fixed, and pgstat_tracks_io_op().

Referenced by GetLocalVictimBuffer(), GetVictimBuffer(), pgstat_count_io_op_time(), and TrackBufferHit().

pgstat_count_io_op_time()

void pgstat_count_io_op_time ( IOObject  io_object, IOContext  io_context, IOOp  io_op, instr_time  start_time, uint32  cnt, uint64  bytes  )

extern

Definition at line 122 of file pgstat_io.c.

{
    if (!INSTR_TIME_IS_ZERO(start_time))
    {
        instr_time  io_time;
 
        INSTR_TIME_SET_CURRENT(io_time);
        INSTR_TIME_SUBTRACT(io_time, start_time);
 
        if (io_object != IOOBJECT_WAL)
        {
            if (io_op == IOOP_WRITE || io_op == IOOP_EXTEND)
            {
                pgstat_count_buffer_write_time(INSTR_TIME_GET_MICROSEC(io_time));
                if (io_object == IOOBJECT_RELATION)
                    INSTR_TIME_ADD(pgBufferUsage.shared_blk_write_time, io_time);
                else if (io_object == IOOBJECT_TEMP_RELATION)
                    INSTR_TIME_ADD(pgBufferUsage.local_blk_write_time, io_time);
            }
            else if (io_op == IOOP_READ)
            {
                pgstat_count_buffer_read_time(INSTR_TIME_GET_MICROSEC(io_time));
                if (io_object == IOOBJECT_RELATION)
                    INSTR_TIME_ADD(pgBufferUsage.shared_blk_read_time, io_time);
                else if (io_object == IOOBJECT_TEMP_RELATION)
                    INSTR_TIME_ADD(pgBufferUsage.local_blk_read_time, io_time);
            }
        }
 
        INSTR_TIME_ADD(PendingIOStats.pending_times[io_object][io_context][io_op],
                       io_time);
 
        /* Add the per-backend count */
        pgstat_count_backend_io_op_time(io_object, io_context, io_op,
                                        io_time);
    }
 
    pgstat_count_io_op(io_object, io_context, io_op, cnt, bytes);
}

References fb(), INSTR_TIME_ADD, INSTR_TIME_GET_MICROSEC, INSTR_TIME_IS_ZERO, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, IOOBJECT_RELATION, IOOBJECT_TEMP_RELATION, IOOBJECT_WAL, IOOP_EXTEND, IOOP_READ, IOOP_WRITE, BufferUsage::local_blk_read_time, BufferUsage::local_blk_write_time, PgStat_PendingIO::pending_times, PendingIOStats, pgBufferUsage, pgstat_count_backend_io_op_time(), pgstat_count_buffer_read_time, pgstat_count_buffer_write_time, pgstat_count_io_op(), BufferUsage::shared_blk_read_time, BufferUsage::shared_blk_write_time, and start_time.

Referenced by AsyncReadBuffers(), ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushBuffer(), FlushLocalBuffer(), issue_xlog_fsync(), IssuePendingWritebacks(), mdsyncfiletag(), register_dirty_segment(), WaitReadBuffers(), WALRead(), XLogFileInitInternal(), XLogPageRead(), XLogWalRcvWrite(), and XLogWrite().

pgstat_count_lock_fastpath_exceeded()

void pgstat_count_lock_fastpath_exceeded ( uint8  locktag_type )

extern

Definition at line 128 of file pgstat_lock.c.

{
    Assert(locktag_type <= LOCKTAG_LAST_TYPE);
    PendingLockStats.stats[locktag_type].fastpath_exceeded++;
    have_lockstats = true;
    pgstat_report_fixed = true;
}

References Assert, PgStat_LockEntry::fastpath_exceeded, have_lockstats, LOCKTAG_LAST_TYPE, PendingLockStats, pgstat_report_fixed, and PgStat_PendingLock::stats.

Referenced by LockAcquireExtended().

pgstat_count_lock_waits()

void pgstat_count_lock_waits ( uint8  locktag_type, long  msecs  )

extern

Definition at line 143 of file pgstat_lock.c.

{
    Assert(locktag_type <= LOCKTAG_LAST_TYPE);
    PendingLockStats.stats[locktag_type].waits++;
    PendingLockStats.stats[locktag_type].wait_time += (PgStat_Counter) msecs;
    have_lockstats = true;
    pgstat_report_fixed = true;
}

References Assert, fb(), have_lockstats, LOCKTAG_LAST_TYPE, PendingLockStats, pgstat_report_fixed, PgStat_PendingLock::stats, PgStat_LockEntry::wait_time, and PgStat_LockEntry::waits.

Referenced by ProcSleep().

pgstat_count_slru_blocks_exists()

void pgstat_count_slru_blocks_exists ( int  slru_idx )

extern

Referenced by SimpleLruDoesPhysicalPageExist().

pgstat_count_slru_blocks_hit()

void pgstat_count_slru_blocks_hit ( int  slru_idx )

extern

Referenced by SimpleLruReadPage(), and SimpleLruReadPage_ReadOnly().

pgstat_count_slru_blocks_read()

void pgstat_count_slru_blocks_read ( int  slru_idx )

extern

Referenced by SimpleLruReadPage().

pgstat_count_slru_blocks_written()

void pgstat_count_slru_blocks_written ( int  slru_idx )

extern

Referenced by SlruPhysicalWritePage().

pgstat_count_slru_blocks_zeroed()

void pgstat_count_slru_blocks_zeroed ( int  slru_idx )

extern

Referenced by SimpleLruZeroPage().

pgstat_count_slru_flush()

void pgstat_count_slru_flush ( int  slru_idx )

extern

Referenced by SimpleLruWriteAll().

pgstat_count_slru_truncate()

void pgstat_count_slru_truncate ( int  slru_idx )

extern

Referenced by SimpleLruTruncate().

pgstat_count_truncate()

void pgstat_count_truncate ( Relation  rel )

extern

Definition at line 430 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 ExecuteTruncateGuts(), and RefreshMatViewByOid().

pgstat_create_backend()

void pgstat_create_backend ( ProcNumber  procnum )

extern

Definition at line 324 of file pgstat_backend.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Backend *shstatent;
 
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_BACKEND, InvalidOid,
                                            procnum, false);
    shstatent = (PgStatShared_Backend *) entry_ref->shared_stats;
 
    /*
     * NB: need to accept that there might be stats from an older backend,
     * e.g. if we previously used this proc number.
     */
    memset(&shstatent->stats, 0, sizeof(shstatent->stats));
    pgstat_unlock_entry(entry_ref);
 
    MemSet(&PendingBackendStats, 0, sizeof(PgStat_BackendPending));
    backend_has_iostats = false;
 
    /*
     * Initialize prevBackendWalUsage with pgWalUsage so that
     * pgstat_backend_flush_cb() can calculate how much pgWalUsage counters
     * are increased by subtracting prevBackendWalUsage from pgWalUsage.
     */
    prevBackendWalUsage = pgWalUsage;
}

References backend_has_iostats, fb(), InvalidOid, MemSet, PendingBackendStats, pgstat_get_entry_ref_locked(), PGSTAT_KIND_BACKEND, pgstat_unlock_entry(), pgWalUsage, prevBackendWalUsage, and PgStat_EntryRef::shared_stats.

Referenced by pgstat_bestart_final().

pgstat_create_function()

void pgstat_create_function ( Oid  proid )

extern

Definition at line 45 of file pgstat_function.c.

{
    pgstat_create_transactional(PGSTAT_KIND_FUNCTION,
                                MyDatabaseId,
                                proid);
}

References fb(), MyDatabaseId, pgstat_create_transactional(), and PGSTAT_KIND_FUNCTION.

Referenced by ProcedureCreate().

pgstat_create_relation()

void pgstat_create_relation ( Relation  rel )

extern

Definition at line 169 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 )

extern

Definition at line 141 of file pgstat_replslot.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_ReplSlot *shstatent;
 
    Assert(LWLockHeldByMeInMode(ReplicationSlotAllocationLock, LW_EXCLUSIVE));
 
    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 Assert, fb(), InvalidOid, LW_EXCLUSIVE, LWLockHeldByMeInMode(), pgstat_get_entry_ref_locked(), PGSTAT_KIND_REPLSLOT, pgstat_unlock_entry(), ReplicationSlotIndex(), and PgStat_EntryRef::shared_stats.

Referenced by ReplicationSlotCreate().

pgstat_create_subscription()

void pgstat_create_subscription ( Oid  subid )

extern

Definition at line 78 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 fb(), 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  )

extern

Definition at line 537 of file pgstat.c.

{
    int         ret;
 
    /* NB: this needs to be done even in single user mode */
 
    /* First, cleanup the main pgstats file */
    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)));
    }
 
    /* Finish callbacks, if required */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (kind_info && kind_info->finish)
            kind_info->finish(STATS_DISCARD);
    }
 
    /*
     * 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(), fb(), LOG, pgstat_get_kind_info(), PgStat_Kind, PGSTAT_KIND_MAX, PGSTAT_KIND_MIN, pgstat_reset_after_failure(), PGSTAT_STAT_PERMANENT_FILENAME, and STATS_DISCARD.

Referenced by StartupXLOG().

pgstat_drop_database()

void pgstat_drop_database ( Oid  databaseid )

extern

Definition at line 44 of file pgstat_database.c.

{
    pgstat_drop_transactional(PGSTAT_KIND_DATABASE, databaseid, InvalidOid);
}

References fb(), InvalidOid, pgstat_drop_transactional(), and PGSTAT_KIND_DATABASE.

Referenced by dropdb().

pgstat_drop_function()

void pgstat_drop_function ( Oid  proid )

extern

Definition at line 60 of file pgstat_function.c.

{
    pgstat_drop_transactional(PGSTAT_KIND_FUNCTION,
                              MyDatabaseId,
                              proid);
}

References fb(), MyDatabaseId, pgstat_drop_transactional(), and PGSTAT_KIND_FUNCTION.

Referenced by RemoveFunctionById().

pgstat_drop_relation()

void pgstat_drop_relation ( Relation  rel )

extern

Definition at line 180 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 )

extern

Definition at line 186 of file pgstat_replslot.c.

{
    Assert(LWLockHeldByMeInMode(ReplicationSlotAllocationLock, LW_EXCLUSIVE));
 
    if (!pgstat_drop_entry(PGSTAT_KIND_REPLSLOT, InvalidOid,
                           ReplicationSlotIndex(slot)))
        pgstat_request_entry_refs_gc();
}

References Assert, fb(), InvalidOid, LW_EXCLUSIVE, LWLockHeldByMeInMode(), pgstat_drop_entry(), PGSTAT_KIND_REPLSLOT, pgstat_request_entry_refs_gc(), and ReplicationSlotIndex().

Referenced by ReplicationSlotDropPtr().

pgstat_drop_subscription()

void pgstat_drop_subscription ( Oid  subid )

extern

Definition at line 96 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  )

extern

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 fb(), INSTR_TIME_ADD, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, PgStat_FunctionCounts::numcalls, PgStat_FunctionCounts::self_time, 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  )

extern

Definition at line 314 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];
        uint64      objid = ((uint64) it->objid_hi) << 32 | it->objid_lo;
 
        if (!pgstat_drop_entry(it->kind, it->dboid, objid))
            not_freed_count++;
    }
 
    if (not_freed_count > 0)
        pgstat_request_entry_refs_gc();
}

References fb(), i, items, 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 )

extern

Definition at line 200 of file pgstat_replslot.c.

{
    int         idx;
    PgStat_StatReplSlotEntry *slotentry = NULL;
 
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
 
    idx = get_replslot_index(NameStr(slotname), false);
 
    if (idx != -1)
        slotentry = (PgStat_StatReplSlotEntry *) pgstat_fetch_entry(PGSTAT_KIND_REPLSLOT,
                                                                    InvalidOid, idx,
                                                                    NULL);
 
    LWLockRelease(ReplicationSlotControlLock);
 
    return slotentry;
}

References fb(), get_replslot_index(), idx(), InvalidOid, LW_SHARED, LWLockAcquire(), LWLockRelease(), NameStr, pgstat_fetch_entry(), and PGSTAT_KIND_REPLSLOT.

Referenced by pg_stat_get_replication_slot().

pgstat_fetch_slru()

PgStat_SLRUStats * pgstat_fetch_slru ( void  )

extern

Definition at line 91 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  )

extern

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_backend()

PgStat_Backend * pgstat_fetch_stat_backend ( ProcNumber  procNumber )

extern

Definition at line 93 of file pgstat_backend.c.

{
    PgStat_Backend *backend_entry;
 
    backend_entry = (PgStat_Backend *) pgstat_fetch_entry(PGSTAT_KIND_BACKEND,
                                                          InvalidOid, procNumber,
                                                          NULL);
 
    return backend_entry;
}

References fb(), InvalidOid, pgstat_fetch_entry(), and PGSTAT_KIND_BACKEND.

Referenced by pgstat_fetch_stat_backend_by_pid().

pgstat_fetch_stat_backend_by_pid()

PgStat_Backend * pgstat_fetch_stat_backend_by_pid ( int  pid, BackendType *  bktype  )

extern

Definition at line 112 of file pgstat_backend.c.

{
    PGPROC     *proc;
    PgBackendStatus *beentry;
    ProcNumber  procNumber;
    PgStat_Backend *backend_stats;
 
    proc = BackendPidGetProc(pid);
    if (bktype)
        *bktype = B_INVALID;
 
    /* this could be an auxiliary process */
    if (!proc)
        proc = AuxiliaryPidGetProc(pid);
 
    if (!proc)
        return NULL;
 
    procNumber = GetNumberFromPGProc(proc);
 
    beentry = pgstat_get_beentry_by_proc_number(procNumber);
    if (!beentry)
        return NULL;
 
    /* check if the backend type tracks statistics */
    if (!pgstat_tracks_backend_bktype(beentry->st_backendType))
        return NULL;
 
    /* if PID does not match, leave */
    if (beentry->st_procpid != pid)
        return NULL;
 
    if (bktype)
        *bktype = beentry->st_backendType;
 
    /*
     * Retrieve the entry.  Note that "beentry" may be freed depending on the
     * value of stats_fetch_consistency, so do not access it from this point.
     */
    backend_stats = pgstat_fetch_stat_backend(procNumber);
    if (!backend_stats)
    {
        if (bktype)
            *bktype = B_INVALID;
        return NULL;
    }
 
    return backend_stats;
}

References AuxiliaryPidGetProc(), B_INVALID, BackendPidGetProc(), fb(), GetNumberFromPGProc, pgstat_fetch_stat_backend(), pgstat_get_beentry_by_proc_number(), and pgstat_tracks_backend_bktype().

Referenced by pg_stat_get_backend_io(), and pg_stat_get_backend_wal().

pgstat_fetch_stat_bgwriter()

PgStat_BgWriterStats * pgstat_fetch_stat_bgwriter ( void  )

extern

Definition at line 72 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  )

extern

Definition at line 81 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_checkpointer_buffers_written(), pg_stat_get_checkpointer_num_performed(), pg_stat_get_checkpointer_num_requested(), pg_stat_get_checkpointer_num_timed(), pg_stat_get_checkpointer_restartpoints_performed(), pg_stat_get_checkpointer_restartpoints_requested(), pg_stat_get_checkpointer_restartpoints_timed(), pg_stat_get_checkpointer_slru_written(), pg_stat_get_checkpointer_stat_reset_time(), pg_stat_get_checkpointer_sync_time(), and pg_stat_get_checkpointer_write_time().

pgstat_fetch_stat_dbentry()

PgStat_StatDBEntry * pgstat_fetch_stat_dbentry ( Oid  dboid )

extern

Definition at line 288 of file pgstat_database.c.

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

References fb(), 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 )

extern

Definition at line 245 of file pgstat_function.c.

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

References fb(), MyDatabaseId, pgstat_fetch_entry(), and PGSTAT_KIND_FUNCTION.

Referenced by pg_stat_get_function_calls(), and pg_stat_get_function_stat_reset_time().

pgstat_fetch_stat_io()

PgStat_IO * pgstat_fetch_stat_io ( void  )

extern

Definition at line 164 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_lock()

PgStat_Lock * pgstat_fetch_stat_lock ( void  )

extern

Definition at line 26 of file pgstat_lock.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_LOCK);
 
    return &pgStatLocal.snapshot.lock;
}

References PgStat_Snapshot::lock, PGSTAT_KIND_LOCK, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_lock().

pgstat_fetch_stat_subscription()

PgStat_StatSubEntry * pgstat_fetch_stat_subscription ( Oid  subid )

extern

Definition at line 107 of file pgstat_subscription.c.

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

References fb(), 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 )

extern

Definition at line 470 of file pgstat_relation.c.

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

References fb(), IsSharedRelation(), and pgstat_fetch_stat_tabentry_ext().

pgstat_fetch_stat_tabentry_ext()

PgStat_StatTabEntry * pgstat_fetch_stat_tabentry_ext ( bool  shared, Oid  reloid, bool *  may_free  )

extern

Definition at line 481 of file pgstat_relation.c.

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

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

Referenced by pgstat_copy_relation_stats(), pgstat_fetch_stat_tabentry(), and relation_needs_vacanalyze().

pgstat_fetch_stat_wal()

PgStat_WalStats * pgstat_fetch_stat_wal ( void  )

extern

Definition at line 67 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  )

extern

Definition at line 842 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 )

extern

Definition at line 240 of file pgstat_io.c.

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

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

Referenced by pg_stat_io_build_tuples().

pgstat_get_io_object_name()

const char * pgstat_get_io_object_name ( IOObject  io_object )

extern

Definition at line 261 of file pgstat_io.c.

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

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

Referenced by pg_stat_io_build_tuples().

pgstat_get_kind_from_str()

PgStat_Kind pgstat_get_kind_from_str ( char *  kind_str )

extern

Definition at line 1445 of file pgstat.c.

{
    for (PgStat_Kind kind = PGSTAT_KIND_BUILTIN_MIN; kind <= PGSTAT_KIND_BUILTIN_MAX; kind++)
    {
        if (pg_strcasecmp(kind_str, pgstat_kind_builtin_infos[kind].name) == 0)
            return kind;
    }
 
    /* Check the custom set of cumulative stats */
    if (pgstat_kind_custom_infos)
    {
        for (PgStat_Kind kind = PGSTAT_KIND_CUSTOM_MIN; kind <= PGSTAT_KIND_CUSTOM_MAX; kind++)
        {
            uint32      idx = kind - PGSTAT_KIND_CUSTOM_MIN;
 
            if (pgstat_kind_custom_infos[idx] &&
                pg_strcasecmp(kind_str, pgstat_kind_custom_infos[idx]->name) == 0)
                return kind;
        }
    }
 
    ereport(ERROR,
            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
             errmsg("invalid statistics kind: \"%s\"", kind_str)));
    return PGSTAT_KIND_INVALID; /* avoid compiler warnings */

References ereport, errcode(), errmsg, ERROR, fb(), idx(), name, pg_strcasecmp(), PgStat_Kind, pgstat_kind_builtin_infos, PGSTAT_KIND_BUILTIN_MAX, PGSTAT_KIND_BUILTIN_MIN, pgstat_kind_custom_infos, PGSTAT_KIND_CUSTOM_MAX, PGSTAT_KIND_CUSTOM_MIN, and PGSTAT_KIND_INVALID.

Referenced by pg_stat_have_stats().

pgstat_get_slru_index()

int pgstat_get_slru_index ( const char *  name )

extern

Definition at line 118 of file pgstat_slru.c.

{
    int         i;
 
    Assert(name);
    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 Assert, fb(), i, name, slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pgstat_reset_slru(), and shmem_slru_init().

pgstat_get_slru_name()

const char * pgstat_get_slru_name ( int  slru_idx )

extern

Definition at line 104 of file pgstat_slru.c.

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

References fb(), 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 )

extern

Definition at line 1071 of file pgstat.c.

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

References fb(), force_stats_snapshot_clear, PgStat_Snapshot::mode, pgstat_clear_snapshot(), 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  )

extern

Definition at line 272 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, fb(), PgStat_PendingDroppedStatsItem::is_create, PgStat_PendingDroppedStatsItem::item, items, 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, uint64  objid  )

extern

Definition at line 1088 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, objid, false, NULL) != NULL;

References fb(), 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  )

extern

pgstat_init_relation()

void pgstat_init_relation ( Relation  rel )

extern

Definition at line 92 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 fb(), 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  )

extern

Definition at line 669 of file pgstat.c.

{
    Assert(!pgstat_is_initialized);
 
    pgstat_attach_shmem();
 
    pgstat_init_snapshot_fixed();
 
    /* Backend initialization callbacks */
    for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
    {
        const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
        if (kind_info == NULL || kind_info->init_backend_cb == NULL)
            continue;
 
        kind_info->init_backend_cb();
    }
 
    /* 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(), fb(), pgstat_attach_shmem(), pgstat_get_kind_info(), pgstat_init_snapshot_fixed(), PgStat_Kind, PGSTAT_KIND_MAX, PGSTAT_KIND_MIN, and pgstat_shutdown_hook().

Referenced by BaseInit().

pgstat_lock_flush()

void pgstat_lock_flush ( bool  nowait )

extern

Definition at line 37 of file pgstat_lock.c.

{
    (void) pgstat_lock_flush_cb(nowait);
}

References fb(), and pgstat_lock_flush_cb().

pgstat_prepare_io_time()

instr_time pgstat_prepare_io_time ( bool  track_io_guc )

extern

Definition at line 91 of file pgstat_io.c.

{
    instr_time  io_start;
 
    if (track_io_guc)
        INSTR_TIME_SET_CURRENT(io_start);
    else
    {
        /*
         * There is no need to set io_start when an IO timing GUC is disabled.
         * Initialize it to zero to avoid compiler warnings and to let
         * pgstat_count_io_op_time() know that timings should be ignored.
         */
        INSTR_TIME_SET_ZERO(io_start);
    }
 
    return io_start;
}

References fb(), INSTR_TIME_SET_CURRENT, and INSTR_TIME_SET_ZERO.

Referenced by AsyncReadBuffers(), ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushBuffer(), FlushLocalBuffer(), issue_xlog_fsync(), IssuePendingWritebacks(), mdsyncfiletag(), register_dirty_segment(), WaitReadBuffers(), WALRead(), XLogFileInitInternal(), XLogPageRead(), XLogWalRcvWrite(), and XLogWrite().

pgstat_prepare_report_checksum_failure()

void pgstat_prepare_report_checksum_failure ( Oid  dboid )

extern

Definition at line 155 of file pgstat_database.c.

{
    Assert(!CritSectionCount);
 
    /*
     * Just need to ensure this backend has an entry ref for the database.
     * That will allows us to report checksum failures without e.g. needing to
     * map in DSM segments.
     */
    pgstat_get_entry_ref(PGSTAT_KIND_DATABASE, dboid, InvalidOid,
                         true, NULL);
}

References Assert, CritSectionCount, fb(), InvalidOid, pgstat_get_entry_ref(), and PGSTAT_KIND_DATABASE.

Referenced by AsyncReadBuffers(), read_rel_block_ll(), RelationCopyStorage(), and sendFile().

pgstat_report_analyze()

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

extern

Definition at line 282 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Relation *shtabentry;
    PgStat_StatTabEntry *tabentry;
    Oid         dboid = (rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId);
    TimestampTz ts;
    PgStat_Counter elapsedtime;
 
    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);
    }
 
    /* Store the data in the table's hash table entry. */
    ts = GetCurrentTimestamp();
    elapsedtime = TimestampDifferenceMilliseconds(starttime, ts);
 
    /* 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 (AmAutoVacuumWorkerProcess())
    {
        tabentry->last_autoanalyze_time = ts;
        tabentry->autoanalyze_count++;
        tabentry->total_autoanalyze_time += elapsedtime;
    }
    else
    {
        tabentry->last_analyze_time = ts;
        tabentry->analyze_count++;
        tabentry->total_analyze_time += elapsedtime;
    }
 
    pgstat_unlock_entry(entry_ref);
 
    /* see pgstat_report_vacuum() */
    pgstat_flush_io(false);
    (void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO);
}

References AmAutoVacuumWorkerProcess, Assert, PgStat_TableStatus::counts, PgStat_TableCounts::delta_dead_tuples, fb(), GetCurrentTimestamp(), InvalidOid, Max, MyDatabaseId, PGSTAT_BACKEND_FLUSH_IO, pgstat_flush_backend(), 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, TimestampDifferenceMilliseconds(), PgStat_TableStatus::trans, trans, and PgStat_TableXactStatus::tuples_inserted.

Referenced by do_analyze_rel().

pgstat_report_archiver()

void pgstat_report_archiver ( const char *  xlog, bool  failed  )

extern

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_ShmemControl::archiver, fb(), GetCurrentTimestamp(), memcpy(), now(), pgstat_begin_changecount_write(), pgstat_end_changecount_write(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by pgarch_ArchiverCopyLoop().

pgstat_report_autovac()

void pgstat_report_autovac ( Oid  dboid )

extern

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, fb(), GetCurrentTimestamp(), InvalidOid, IsUnderPostmaster, pgstat_get_entry_ref_locked(), PGSTAT_KIND_DATABASE, pgstat_unlock_entry(), and PgStat_EntryRef::shared_stats.

Referenced by AutoVacWorkerMain().

pgstat_report_bgwriter()

void pgstat_report_bgwriter ( void  )

extern

Definition at line 31 of file pgstat_bgwriter.c.

{
    PgStatShared_BgWriter *stats_shmem = &pgStatLocal.shmem->bgwriter;
 
    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 (pg_memory_is_all_zeros(&PendingBgWriterStats,
                               sizeof(struct PgStat_BgWriterStats)))
        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, fb(), PgStat_ShmemControl::is_shutdown, MemSet, PendingBgWriterStats, pg_memory_is_all_zeros(), 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  )

extern

Definition at line 31 of file pgstat_checkpointer.c.

{
    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 (pg_memory_is_all_zeros(&PendingCheckpointerStats,
                               sizeof(struct PgStat_CheckpointerStats)))
        return;
 
    pgstat_begin_changecount_write(&stats_shmem->changecount);
 
#define CHECKPOINTER_ACC(fld) stats_shmem->stats.fld += PendingCheckpointerStats.fld
    CHECKPOINTER_ACC(num_timed);
    CHECKPOINTER_ACC(num_requested);
    CHECKPOINTER_ACC(num_performed);
    CHECKPOINTER_ACC(restartpoints_timed);
    CHECKPOINTER_ACC(restartpoints_requested);
    CHECKPOINTER_ACC(restartpoints_performed);
    CHECKPOINTER_ACC(write_time);
    CHECKPOINTER_ACC(sync_time);
    CHECKPOINTER_ACC(buffers_written);
    CHECKPOINTER_ACC(slru_written);
#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, PgStat_ShmemControl::checkpointer, CHECKPOINTER_ACC, fb(), PgStat_ShmemControl::is_shutdown, MemSet, PendingCheckpointerStats, pg_memory_is_all_zeros(), pgstat_assert_is_up, pgstat_begin_changecount_write(), pgstat_end_changecount_write(), pgstat_flush_io(), pgStatLocal, and PgStat_LocalState::shmem.

Referenced by CheckpointerMain(), and CheckpointWriteDelay().

pgstat_report_checksum_failures_in_db()

void pgstat_report_checksum_failures_in_db ( Oid  dboid, int  failurecount  )

extern

Definition at line 176 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. Note that we pass create=false
     * here, as we want to be sure to not require memory allocations, so this
     * can be called in critical sections.
     */
    entry_ref = pgstat_get_entry_ref(PGSTAT_KIND_DATABASE, dboid, InvalidOid,
                                     false, NULL);
 
    /*
     * Should always have been created by
     * pgstat_prepare_report_checksum_failure().
     *
     * When not using assertions, we don't want to crash should something have
     * gone wrong, so just return.
     */
    Assert(entry_ref);
    if (!entry_ref)
    {
        elog(WARNING, "could not report %d checksum failures for database %u",
             failurecount, dboid);
        return;
    }
 
    (void) pgstat_lock_entry(entry_ref, 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 Assert, elog, fb(), GetCurrentTimestamp(), InvalidOid, pgstat_get_entry_ref(), PGSTAT_KIND_DATABASE, pgstat_lock_entry(), pgstat_track_counts, pgstat_unlock_entry(), PgStat_EntryRef::shared_stats, and WARNING.

Referenced by buffer_readv_complete(), RelationCopyStorage(), sendFile(), and shared_buffer_readv_complete_local().

pgstat_report_connect()

void pgstat_report_connect ( Oid  dboid )

extern

Definition at line 237 of file pgstat_database.c.

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

References fb(), MyStartTimestamp, pgLastSessionReportTime, pgstat_prep_database_pending(), and pgstat_should_report_connstat().

Referenced by PostgresMain().

pgstat_report_deadlock()

void pgstat_report_deadlock ( void  )

extern

Definition at line 135 of file pgstat_database.c.

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

References fb(), MyDatabaseId, pgstat_prep_database_pending(), and pgstat_track_counts.

Referenced by DeadLockReport().

pgstat_report_recovery_conflict()

void pgstat_report_recovery_conflict ( int  reason )

extern

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 ((RecoveryConflictReason) reason)
    {
        case 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 RECOVERY_CONFLICT_TABLESPACE:
            dbentry->conflict_tablespace++;
            break;
        case RECOVERY_CONFLICT_LOCK:
            dbentry->conflict_lock++;
            break;
        case RECOVERY_CONFLICT_SNAPSHOT:
            dbentry->conflict_snapshot++;
            break;
        case RECOVERY_CONFLICT_BUFFERPIN:
            dbentry->conflict_bufferpin++;
            break;
        case RECOVERY_CONFLICT_LOGICALSLOT:
            dbentry->conflict_logicalslot++;
            break;
        case RECOVERY_CONFLICT_STARTUP_DEADLOCK:
            dbentry->conflict_startup_deadlock++;
            break;
        case RECOVERY_CONFLICT_BUFFERPIN_DEADLOCK:
 
            /*
             * The difference between RECOVERY_CONFLICT_STARTUP_DEADLOCK and
             * RECOVERY_CONFLICT_BUFFERPIN_DEADLOCK is merely whether a buffer
             * pin was part of the deadlock. We use the same counter for both
             * reasons.
             */
            dbentry->conflict_startup_deadlock++;
            break;
    }
}

References Assert, fb(), IsUnderPostmaster, MyDatabaseId, pgstat_prep_database_pending(), pgstat_track_counts, RECOVERY_CONFLICT_BUFFERPIN, RECOVERY_CONFLICT_BUFFERPIN_DEADLOCK, RECOVERY_CONFLICT_DATABASE, RECOVERY_CONFLICT_LOCK, RECOVERY_CONFLICT_LOGICALSLOT, RECOVERY_CONFLICT_SNAPSHOT, RECOVERY_CONFLICT_STARTUP_DEADLOCK, and RECOVERY_CONFLICT_TABLESPACE.

Referenced by report_recovery_conflict().

pgstat_report_replslot()

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

extern

Definition at line 77 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(mem_exceeded_count);
    REPLSLOT_ACC(total_txns);
    REPLSLOT_ACC(total_bytes);
#undef REPLSLOT_ACC
 
    pgstat_unlock_entry(entry_ref);
}

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

Referenced by UpdateDecodingStats().

pgstat_report_replslotsync()

void pgstat_report_replslotsync ( struct ReplicationSlot *  slot )

extern

Definition at line 111 of file pgstat_replslot.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_ReplSlot *shstatent;
    PgStat_StatReplSlotEntry *statent;
 
    /* Slot sync stats are valid only for synced logical slots on standby. */
    Assert(slot->data.synced);
    Assert(RecoveryInProgress());
 
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_REPLSLOT, InvalidOid,
                                            ReplicationSlotIndex(slot), false);
    Assert(entry_ref != NULL);
 
    shstatent = (PgStatShared_ReplSlot *) entry_ref->shared_stats;
    statent = &shstatent->stats;
 
    statent->slotsync_skip_count += 1;
    statent->slotsync_last_skip = GetCurrentTimestamp();
 
    pgstat_unlock_entry(entry_ref);
}

References Assert, ReplicationSlot::data, fb(), GetCurrentTimestamp(), InvalidOid, pgstat_get_entry_ref_locked(), PGSTAT_KIND_REPLSLOT, pgstat_unlock_entry(), RecoveryInProgress(), ReplicationSlotIndex(), PgStat_EntryRef::shared_stats, and ReplicationSlotPersistentData::synced.

Referenced by update_slotsync_skip_stats().

pgstat_report_stat()

long pgstat_report_stat ( bool  force )

extern

Definition at line 722 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) &&
        !pgstat_report_fixed)
    {
        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);
 
    if (force)
    {
        /*
         * Stats reports are forced either when it's been too long since stats
         * have been reported or in processes that force stats reporting to
         * happen at specific points (including shutdown). In the former case
         * the transaction stop time might be quite old, in the latter it
         * would never get cleared.
         */
        now = GetCurrentTimestamp();
    }
    else
    {
        now = GetCurrentTransactionStopTimestamp();
 
        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 of variable-numbered stats tracked in pending entries list */
    partial_flush |= pgstat_flush_pending_entries(nowait);
 
    /* flush of other stats kinds */
    if (pgstat_report_fixed)
    {
        for (PgStat_Kind kind = PGSTAT_KIND_MIN; kind <= PGSTAT_KIND_MAX; kind++)
        {
            const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
 
            if (!kind_info)
                continue;
            if (!kind_info->flush_static_cb)
                continue;
 
            partial_flush |= kind_info->flush_static_cb(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;
    pgstat_report_fixed = false;
 
    return 0;

References Assert, dlist_is_empty(), fb(), GetCurrentTimestamp(), GetCurrentTransactionStopTimestamp(), PgStat_ShmemControl::is_shutdown, IsTransactionOrTransactionBlock(), now(), pgstat_assert_is_up, pgstat_flush_pending_entries(), pgstat_get_kind_info(), PGSTAT_IDLE_INTERVAL, PgStat_Kind, PGSTAT_KIND_MAX, PGSTAT_KIND_MIN, PGSTAT_MAX_INTERVAL, PGSTAT_MIN_INTERVAL, pgstat_report_fixed, 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(), FinishSyncWorker(), HasSubscriptionTablesCached(), LogicalRepApplyLoop(), LogicalRepSyncTableStart(), pgstat_before_server_shutdown(), pgstat_shutdown_hook(), PostgresMain(), ProcessInterrupts(), ProcessSequencesForSync(), ProcessSyncingTablesForApply(), ProcessSyncingTablesForSync(), standby_redo(), and worker_spi_main().

pgstat_report_subscription_conflict()

void pgstat_report_subscription_conflict ( Oid  subid, ConflictType  type  )

extern

Definition at line 63 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;
    pending->conflict_count[type]++;
}

References PgStat_BackendSubEntry::conflict_count, fb(), InvalidOid, PgStat_EntryRef::pending, PGSTAT_KIND_SUBSCRIPTION, pgstat_prep_pending_entry(), and type.

Referenced by ReportApplyConflict().

pgstat_report_subscription_error()

void pgstat_report_subscription_error ( Oid  subid )

extern

Definition at line 28 of file pgstat_subscription.c.

{
    PgStat_EntryRef *entry_ref;
    PgStat_BackendSubEntry *pending;
    LogicalRepWorkerType wtype = get_logical_worker_type();
 
    entry_ref = pgstat_prep_pending_entry(PGSTAT_KIND_SUBSCRIPTION,
                                          InvalidOid, subid, NULL);
    pending = entry_ref->pending;
 
    switch (wtype)
    {
        case WORKERTYPE_APPLY:
            pending->apply_error_count++;
            break;
 
        case WORKERTYPE_SEQUENCESYNC:
            pending->sync_seq_error_count++;
            break;
 
        case WORKERTYPE_TABLESYNC:
            pending->sync_table_error_count++;
            break;
 
        default:
            /* Should never happen. */
            Assert(0);
            break;
    }
}

References PgStat_BackendSubEntry::apply_error_count, Assert, fb(), get_logical_worker_type(), InvalidOid, PgStat_EntryRef::pending, PGSTAT_KIND_SUBSCRIPTION, pgstat_prep_pending_entry(), PgStat_BackendSubEntry::sync_seq_error_count, PgStat_BackendSubEntry::sync_table_error_count, WORKERTYPE_APPLY, WORKERTYPE_SEQUENCESYNC, and WORKERTYPE_TABLESYNC.

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

pgstat_report_vacuum()

void pgstat_report_vacuum ( Relation  rel, PgStat_Counter  livetuples, PgStat_Counter  deadtuples, TimestampTz  starttime  )

extern

Definition at line 211 of file pgstat_relation.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Relation *shtabentry;
    PgStat_StatTabEntry *tabentry;
    Oid         dboid = (rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId);
    TimestampTz ts;
    PgStat_Counter elapsedtime;
 
    if (!pgstat_track_counts)
        return;
 
    /* Store the data in the table's hash table entry. */
    ts = GetCurrentTimestamp();
    elapsedtime = TimestampDifferenceMilliseconds(starttime, ts);
 
    /* 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);
 
    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 (AmAutoVacuumWorkerProcess())
    {
        tabentry->last_autovacuum_time = ts;
        tabentry->autovacuum_count++;
        tabentry->total_autovacuum_time += elapsedtime;
    }
    else
    {
        tabentry->last_vacuum_time = ts;
        tabentry->vacuum_count++;
        tabentry->total_vacuum_time += elapsedtime;
    }
 
    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);
    (void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO);
}

References AmAutoVacuumWorkerProcess, fb(), GetCurrentTimestamp(), InvalidOid, MyDatabaseId, PGSTAT_BACKEND_FLUSH_IO, pgstat_flush_backend(), pgstat_flush_io(), pgstat_get_entry_ref_locked(), PGSTAT_KIND_RELATION, pgstat_track_counts, pgstat_unlock_entry(), RelationData::rd_rel, RelationGetRelid, PgStat_EntryRef::shared_stats, and TimestampDifferenceMilliseconds().

Referenced by heap_vacuum_rel().

pgstat_report_wal()

void pgstat_report_wal ( bool  force )

extern

Definition at line 46 of file pgstat_wal.c.

{
    bool        nowait;
 
    /* like in pgstat.c, don't wait for lock acquisition when !force */
    nowait = !force;
 
    /* flush wal stats */
    (void) pgstat_wal_flush_cb(nowait);
    pgstat_flush_backend(nowait, PGSTAT_BACKEND_FLUSH_WAL);
 
    /* flush IO stats */
    pgstat_flush_io(nowait);
    (void) pgstat_flush_backend(nowait, PGSTAT_BACKEND_FLUSH_IO);
}

References fb(), PGSTAT_BACKEND_FLUSH_IO, PGSTAT_BACKEND_FLUSH_WAL, pgstat_flush_backend(), pgstat_flush_io(), and pgstat_wal_flush_cb().

Referenced by BackgroundWriterMain(), CheckpointerMain(), summarizer_wait_for_wal(), WalReceiverMain(), and WalWriterMain().

pgstat_reset()

void pgstat_reset ( PgStat_Kind  kind, Oid  dboid, uint64  objid  )

extern

Definition at line 882 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, objid, ts);
 
    if (!kind_info->accessed_across_databases)
        pgstat_reset_database_timestamp(dboid, ts);

References Assert, fb(), GetCurrentTimestamp(), pgstat_get_kind_info(), pgstat_reset_database_timestamp(), and pgstat_reset_entry().

Referenced by pg_stat_reset_backend_stats(), 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  )

extern

Definition at line 863 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 )

extern

Definition at line 904 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 fb(), GetCurrentTimestamp(), pgstat_get_kind_info(), and pgstat_reset_entries_of_kind().

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

pgstat_reset_replslot()

void pgstat_reset_replslot ( const char *  name )

extern

Definition at line 42 of file pgstat_replslot.c.

{
    ReplicationSlot *slot;
 
    Assert(name != NULL);
 
    LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
 
    /* Check if the slot exists with the given name. */
    slot = SearchNamedReplicationSlot(name, false);
    if (!slot)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("replication slot \"%s\" does not exist",
                        name)));
 
    /*
     * Reset stats if it is a logical slot. Nothing to do for physical slots
     * as we collect stats only for logical slots.
     */
    if (SlotIsLogical(slot))
        pgstat_reset(PGSTAT_KIND_REPLSLOT, InvalidOid,
                     ReplicationSlotIndex(slot));
 
    LWLockRelease(ReplicationSlotControlLock);
}

References Assert, ereport, errcode(), errmsg, ERROR, fb(), InvalidOid, LW_SHARED, LWLockAcquire(), LWLockRelease(), name, PGSTAT_KIND_REPLSLOT, pgstat_reset(), ReplicationSlotIndex(), SearchNamedReplicationSlot(), and SlotIsLogical.

Referenced by pg_stat_reset_replication_slot().

pgstat_reset_slru()

void pgstat_reset_slru ( const char *  name )

extern

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, fb(), 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  )

extern

Definition at line 525 of file pgstat.c.

{
    pgstat_read_statsfile();

References pgstat_read_statsfile().

Referenced by StartupXLOG().

pgstat_tracks_backend_bktype()

bool pgstat_tracks_backend_bktype ( BackendType  bktype )

extern

Definition at line 367 of file pgstat_backend.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_AUTOVAC_LAUNCHER:
        case B_DEAD_END_BACKEND:
        case B_ARCHIVER:
        case B_LOGGER:
        case B_BG_WRITER:
        case B_CHECKPOINTER:
        case B_IO_WORKER:
        case B_STARTUP:
        case B_DATACHECKSUMSWORKER_LAUNCHER:
        case B_DATACHECKSUMSWORKER_WORKER:
            return false;
 
        case B_AUTOVAC_WORKER:
        case B_BACKEND:
        case B_BG_WORKER:
        case B_STANDALONE_BACKEND:
        case B_SLOTSYNC_WORKER:
        case B_WAL_RECEIVER:
        case B_WAL_SENDER:
        case B_WAL_SUMMARIZER:
        case B_WAL_WRITER:
            return true;
    }
 
    return false;
}

References B_ARCHIVER, B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_DATACHECKSUMSWORKER_LAUNCHER, B_DATACHECKSUMSWORKER_WORKER, B_DEAD_END_BACKEND, B_INVALID, B_IO_WORKER, B_LOGGER, B_SLOTSYNC_WORKER, B_STANDALONE_BACKEND, B_STARTUP, B_WAL_RECEIVER, B_WAL_SENDER, B_WAL_SUMMARIZER, B_WAL_WRITER, and fb().

Referenced by pg_stat_reset_backend_stats(), pgstat_bestart_final(), pgstat_count_backend_io_op(), pgstat_count_backend_io_op_time(), pgstat_fetch_stat_backend_by_pid(), and pgstat_flush_backend().

pgstat_tracks_io_bktype()

bool pgstat_tracks_io_bktype ( BackendType  bktype )

extern

Definition at line 351 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_DEAD_END_BACKEND:
        case B_ARCHIVER:
        case B_LOGGER:
            return false;
 
        case B_DATACHECKSUMSWORKER_LAUNCHER:
        case B_DATACHECKSUMSWORKER_WORKER:
        case B_AUTOVAC_LAUNCHER:
        case B_AUTOVAC_WORKER:
        case B_BACKEND:
        case B_BG_WORKER:
        case B_BG_WRITER:
        case B_CHECKPOINTER:
        case B_IO_WORKER:
        case B_SLOTSYNC_WORKER:
        case B_STANDALONE_BACKEND:
        case B_STARTUP:
        case B_WAL_RECEIVER:
        case B_WAL_SENDER:
        case B_WAL_SUMMARIZER:
        case B_WAL_WRITER:
            return true;
    }
 
    return false;
}

References B_ARCHIVER, B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_DATACHECKSUMSWORKER_LAUNCHER, B_DATACHECKSUMSWORKER_WORKER, B_DEAD_END_BACKEND, B_INVALID, B_IO_WORKER, B_LOGGER, B_SLOTSYNC_WORKER, B_STANDALONE_BACKEND, B_STARTUP, B_WAL_RECEIVER, B_WAL_SENDER, B_WAL_SUMMARIZER, B_WAL_WRITER, and fb().

Referenced by pg_stat_get_io(), and pgstat_tracks_io_object().

pgstat_tracks_io_object()

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

extern

Definition at line 395 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 IOOBJECT_WAL objects can only occur in the
     * IOCONTEXT_NORMAL and IOCONTEXT_INIT IOContexts.
     */
    if (io_object == IOOBJECT_WAL &&
        (io_context != IOCONTEXT_NORMAL &&
         io_context != IOCONTEXT_INIT))
        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 ||
        bktype == B_WAL_SUMMARIZER || bktype == B_WAL_WRITER ||
        bktype == B_WAL_RECEIVER;
 
    if (no_temp_rel && io_context == IOCONTEXT_NORMAL &&
        io_object == IOOBJECT_TEMP_RELATION)
        return false;
 
    /*
     * Some BackendTypes only perform IO under IOOBJECT_WAL, hence exclude all
     * rows for all the other objects for these.
     */
    if ((bktype == B_WAL_SUMMARIZER || bktype == B_WAL_RECEIVER ||
         bktype == B_WAL_WRITER) && io_object != IOOBJECT_WAL)
        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, B_WAL_RECEIVER, B_WAL_SUMMARIZER, B_WAL_WRITER, fb(), IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_INIT, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, IOOBJECT_TEMP_RELATION, IOOBJECT_WAL, and pgstat_tracks_io_bktype().

Referenced by pg_stat_io_build_tuples(), 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  )

extern

Definition at line 479 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 &&
        (io_op == IOOP_READ || io_op == IOOP_EVICT || io_op == IOOP_HIT))
        return false;
 
    if (bktype == B_CHECKPOINTER &&
        ((io_object != IOOBJECT_WAL && 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 BackendTypes do not perform reads with IOOBJECT_WAL.
     */
    if (io_object == IOOBJECT_WAL && io_op == IOOP_READ &&
        (bktype == B_WAL_RECEIVER || bktype == B_BG_WRITER ||
         bktype == B_AUTOVAC_LAUNCHER || bktype == B_AUTOVAC_WORKER ||
         bktype == B_WAL_WRITER))
        return false;
 
    /*
     * Temporary tables are not logged and thus do not require fsync'ing.
     * Writeback is not requested for temporary tables.
     */
    if (io_object == IOOBJECT_TEMP_RELATION &&
        (io_op == IOOP_FSYNC || io_op == IOOP_WRITEBACK))
        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;
 
    /*
     * IOOBJECT_WAL IOObject will not do certain IOOps depending on IOContext.
     */
    if (io_object == IOOBJECT_WAL && io_context == IOCONTEXT_INIT &&
        !(io_op == IOOP_WRITE || io_op == IOOP_FSYNC))
        return false;
 
    if (io_object == IOOBJECT_WAL && io_context == IOCONTEXT_NORMAL &&
        !(io_op == IOOP_WRITE || io_op == IOOP_READ || io_op == IOOP_FSYNC))
        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;
 
 
    return true;
}

References B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_WAL_RECEIVER, B_WAL_WRITER, fb(), IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_INIT, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, IOOBJECT_TEMP_RELATION, IOOBJECT_WAL, IOOP_EVICT, IOOP_EXTEND, IOOP_FSYNC, IOOP_HIT, IOOP_READ, IOOP_REUSE, IOOP_WRITE, IOOP_WRITEBACK, and pgstat_tracks_io_object().

Referenced by pg_stat_io_build_tuples(), pgstat_bktype_io_stats_valid(), pgstat_count_backend_io_op(), pgstat_count_backend_io_op_time(), and pgstat_count_io_op().

pgstat_twophase_postabort()

void pgstat_twophase_postabort ( FullTransactionId  fxid, uint16  info, void *  recdata, uint32  len  )

extern

Definition at line 784 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, fb(), 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 ( FullTransactionId  fxid, uint16  info, void *  recdata, uint32  len  )

extern

Definition at line 748 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, fb(), 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 )

extern

Definition at line 153 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, fb(), 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  )

extern

Definition at line 453 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().

pgstat_update_parallel_workers_stats()

void pgstat_update_parallel_workers_stats ( PgStat_Counter  workers_to_launch, PgStat_Counter  workers_launched  )

extern

Definition at line 315 of file pgstat_database.c.

{
    PgStat_StatDBEntry *dbentry;
 
    if (!OidIsValid(MyDatabaseId))
        return;
 
    dbentry = pgstat_prep_database_pending(MyDatabaseId);
    dbentry->parallel_workers_to_launch += workers_to_launch;
    dbentry->parallel_workers_launched += workers_launched;
}

References fb(), MyDatabaseId, OidIsValid, and pgstat_prep_database_pending().

Referenced by standard_ExecutorEnd().

PostPrepare_PgStat()

void PostPrepare_PgStat ( void  )

extern

Definition at line 211 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, fb(), PgStat_SubXactStatus::nest_level, pgstat_clear_snapshot(), pgStatXactStack, PostPrepare_PgStat_Relations(), and PgStat_SubXactStatus::prev.

Referenced by PrepareTransaction().

Variable Documentation

PendingBgWriterStats

PGDLLIMPORT PgStat_BgWriterStats PendingBgWriterStats

extern

Definition at line 24 of file pgstat_bgwriter.c.

{0};

Referenced by BgBufferSync(), and pgstat_report_bgwriter().

PendingCheckpointerStats

PGDLLIMPORT PgStat_CheckpointerStats PendingCheckpointerStats

extern

Definition at line 24 of file pgstat_checkpointer.c.

{0};

Referenced by BufferSync(), CheckpointerMain(), LogCheckpointEnd(), pgstat_report_checkpointer(), and SlruInternalWritePage().

pgstat_fetch_consistency

PGDLLIMPORT int pgstat_fetch_consistency

extern

Definition at line 205 of file pgstat.c.

Referenced by assign_stats_fetch_consistency(), 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 204 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().