PostgreSQL Source Code  git master
pgstat.h File Reference
Include dependency graph for pgstat.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

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

Macros

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

Typedefs

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

Enumerations

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

Functions

Size StatsShmemSize (void)
 
void StatsShmemInit (void)
 
void pgstat_restore_stats (void)
 
void pgstat_discard_stats (void)
 
void pgstat_before_server_shutdown (int code, Datum arg)
 
void pgstat_initialize (void)
 
long pgstat_report_stat (bool force)
 
void pgstat_force_next_flush (void)
 
void pgstat_reset_counters (void)
 
void pgstat_reset (PgStat_Kind kind, Oid dboid, Oid objoid)
 
void pgstat_reset_of_kind (PgStat_Kind kind)
 
void pgstat_clear_snapshot (void)
 
TimestampTz pgstat_get_stat_snapshot_timestamp (bool *have_snapshot)
 
PgStat_Kind pgstat_get_kind_from_str (char *kind_str)
 
bool pgstat_have_entry (PgStat_Kind kind, Oid dboid, Oid objoid)
 
void pgstat_report_archiver (const char *xlog, bool failed)
 
PgStat_ArchiverStatspgstat_fetch_stat_archiver (void)
 
void pgstat_report_bgwriter (void)
 
PgStat_BgWriterStatspgstat_fetch_stat_bgwriter (void)
 
void pgstat_report_checkpointer (void)
 
PgStat_CheckpointerStatspgstat_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)
 
void pgstat_count_io_op_n (IOObject io_object, IOContext io_context, IOOp io_op, uint32 cnt)
 
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)
 
PgStat_IOpgstat_fetch_stat_io (void)
 
const char * pgstat_get_io_context_name (IOContext io_context)
 
const char * pgstat_get_io_object_name (IOObject io_object)
 
bool pgstat_tracks_io_bktype (BackendType bktype)
 
bool pgstat_tracks_io_object (BackendType bktype, IOObject io_object, IOContext io_context)
 
bool pgstat_tracks_io_op (BackendType bktype, IOObject io_object, IOContext io_context, IOOp io_op)
 
void pgstat_drop_database (Oid databaseid)
 
void pgstat_report_autovac (Oid dboid)
 
void pgstat_report_recovery_conflict (int reason)
 
void pgstat_report_deadlock (void)
 
void pgstat_report_checksum_failures_in_db (Oid dboid, int failurecount)
 
void pgstat_report_checksum_failure (void)
 
void pgstat_report_connect (Oid dboid)
 
PgStat_StatDBEntrypgstat_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_StatFuncEntrypgstat_fetch_stat_funcentry (Oid func_id)
 
PgStat_FunctionCountsfind_funcstat_entry (Oid func_id)
 
void pgstat_create_relation (Relation rel)
 
void pgstat_drop_relation (Relation rel)
 
void pgstat_copy_relation_stats (Relation dst, Relation src)
 
void pgstat_init_relation (Relation rel)
 
void pgstat_assoc_relation (Relation rel)
 
void pgstat_unlink_relation (Relation rel)
 
void pgstat_report_vacuum (Oid tableoid, bool shared, PgStat_Counter livetuples, PgStat_Counter deadtuples)
 
void pgstat_report_analyze (Relation rel, PgStat_Counter livetuples, PgStat_Counter deadtuples, bool resetcounter)
 
void pgstat_count_heap_insert (Relation rel, PgStat_Counter n)
 
void pgstat_count_heap_update (Relation rel, bool hot, bool newpage)
 
void pgstat_count_heap_delete (Relation rel)
 
void pgstat_count_truncate (Relation rel)
 
void pgstat_update_heap_dead_tuples (Relation rel, int delta)
 
void pgstat_twophase_postcommit (TransactionId xid, uint16 info, void *recdata, uint32 len)
 
void pgstat_twophase_postabort (TransactionId xid, uint16 info, void *recdata, uint32 len)
 
PgStat_StatTabEntrypgstat_fetch_stat_tabentry (Oid relid)
 
PgStat_StatTabEntrypgstat_fetch_stat_tabentry_ext (bool shared, Oid reloid)
 
PgStat_TableStatusfind_tabstat_entry (Oid rel_id)
 
void pgstat_reset_replslot (const char *name)
 
void pgstat_report_replslot (struct ReplicationSlot *slot, const PgStat_StatReplSlotEntry *repSlotStat)
 
void pgstat_create_replslot (struct ReplicationSlot *slot)
 
void pgstat_acquire_replslot (struct ReplicationSlot *slot)
 
void pgstat_drop_replslot (struct ReplicationSlot *slot)
 
PgStat_StatReplSlotEntrypgstat_fetch_replslot (NameData slotname)
 
void pgstat_reset_slru (const char *)
 
void pgstat_count_slru_page_zeroed (int slru_idx)
 
void pgstat_count_slru_page_hit (int slru_idx)
 
void pgstat_count_slru_page_read (int slru_idx)
 
void pgstat_count_slru_page_written (int slru_idx)
 
void pgstat_count_slru_page_exists (int slru_idx)
 
void pgstat_count_slru_flush (int slru_idx)
 
void pgstat_count_slru_truncate (int slru_idx)
 
const char * pgstat_get_slru_name (int slru_idx)
 
int pgstat_get_slru_index (const char *name)
 
PgStat_SLRUStatspgstat_fetch_slru (void)
 
void pgstat_report_subscription_error (Oid subid, bool is_apply_error)
 
void pgstat_create_subscription (Oid subid)
 
void pgstat_drop_subscription (Oid subid)
 
PgStat_StatSubEntrypgstat_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_WalStatspgstat_fetch_stat_wal (void)
 

Variables

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

Macro Definition Documentation

◆ IOCONTEXT_NUM_TYPES

#define IOCONTEXT_NUM_TYPES   (IOCONTEXT_VACUUM + 1)

Definition at line 294 of file pgstat.h.

◆ IOOBJECT_NUM_TYPES

#define IOOBJECT_NUM_TYPES   (IOOBJECT_TEMP_RELATION + 1)

Definition at line 284 of file pgstat.h.

◆ IOOP_NUM_TYPES

#define IOOP_NUM_TYPES   (IOOP_WRITEBACK + 1)

Definition at line 308 of file pgstat.h.

◆ PG_STAT_TMP_DIR

#define PG_STAT_TMP_DIR   "pg_stat_tmp"

Definition at line 32 of file pgstat.h.

◆ pgstat_count_buffer_hit

#define pgstat_count_buffer_hit (   rel)
Value:
do { \
(rel)->pgstat_info->counts.blocks_hit++; \
} while (0)
#define pgstat_should_count_relation(rel)
Definition: pgstat.h:604

Definition at line 640 of file pgstat.h.

◆ pgstat_count_buffer_read

#define pgstat_count_buffer_read (   rel)
Value:
do { \
(rel)->pgstat_info->counts.blocks_fetched++; \
} while (0)

Definition at line 635 of file pgstat.h.

◆ pgstat_count_buffer_read_time

#define pgstat_count_buffer_read_time (   n)     (pgStatBlockReadTime += (n))

Definition at line 552 of file pgstat.h.

◆ pgstat_count_buffer_write_time

#define pgstat_count_buffer_write_time (   n)     (pgStatBlockWriteTime += (n))

Definition at line 554 of file pgstat.h.

◆ pgstat_count_conn_active_time

#define pgstat_count_conn_active_time (   n)     (pgStatActiveTime += (n))

Definition at line 556 of file pgstat.h.

◆ pgstat_count_conn_txn_idle_time

#define pgstat_count_conn_txn_idle_time (   n)     (pgStatTransactionIdleTime += (n))

Definition at line 558 of file pgstat.h.

◆ pgstat_count_heap_fetch

#define pgstat_count_heap_fetch (   rel)
Value:
do { \
(rel)->pgstat_info->counts.tuples_fetched++; \
} while (0)

Definition at line 620 of file pgstat.h.

◆ pgstat_count_heap_getnext

#define pgstat_count_heap_getnext (   rel)
Value:
do { \
(rel)->pgstat_info->counts.tuples_returned++; \
} while (0)

Definition at line 615 of file pgstat.h.

◆ pgstat_count_heap_scan

#define pgstat_count_heap_scan (   rel)
Value:
do { \
(rel)->pgstat_info->counts.numscans++; \
} while (0)

Definition at line 610 of file pgstat.h.

◆ pgstat_count_index_scan

#define pgstat_count_index_scan (   rel)
Value:
do { \
(rel)->pgstat_info->counts.numscans++; \
} while (0)

Definition at line 625 of file pgstat.h.

◆ pgstat_count_index_tuples

#define pgstat_count_index_tuples (   rel,
 
)
Value:
do { \
(rel)->pgstat_info->counts.tuples_returned += (n); \
} while (0)

Definition at line 630 of file pgstat.h.

◆ PGSTAT_FILE_FORMAT_ID

#define PGSTAT_FILE_FORMAT_ID   0x01A5BCAC

Definition at line 238 of file pgstat.h.

◆ PGSTAT_KIND_FIRST_VALID

#define PGSTAT_KIND_FIRST_VALID   PGSTAT_KIND_DATABASE

Definition at line 56 of file pgstat.h.

◆ PGSTAT_KIND_LAST

#define PGSTAT_KIND_LAST   PGSTAT_KIND_WAL

Definition at line 57 of file pgstat.h.

◆ PGSTAT_NUM_KINDS

#define PGSTAT_NUM_KINDS   (PGSTAT_KIND_LAST + 1)

Definition at line 58 of file pgstat.h.

◆ pgstat_should_count_relation

#define pgstat_should_count_relation (   rel)
Value:
(likely((rel)->pgstat_info != NULL) ? true : \
((rel)->pgstat_enabled ? pgstat_assoc_relation(rel), true : false))
#define likely(x)
Definition: c.h:310
return true
Definition: isn.c:126
void pgstat_assoc_relation(Relation rel)

Definition at line 604 of file pgstat.h.

◆ PGSTAT_STAT_PERMANENT_DIRECTORY

#define PGSTAT_STAT_PERMANENT_DIRECTORY   "pg_stat"

Definition at line 27 of file pgstat.h.

◆ PGSTAT_STAT_PERMANENT_FILENAME

#define PGSTAT_STAT_PERMANENT_FILENAME   "pg_stat/pgstat.stat"

Definition at line 28 of file pgstat.h.

◆ PGSTAT_STAT_PERMANENT_TMPFILE

#define PGSTAT_STAT_PERMANENT_TMPFILE   "pg_stat/pgstat.tmp"

Definition at line 29 of file pgstat.h.

Typedef Documentation

◆ IOContext

typedef enum IOContext IOContext

◆ IOObject

typedef enum IOObject IOObject

◆ IOOp

typedef enum IOOp IOOp

◆ PgStat_ArchiverStats

◆ PgStat_BackendSubEntry

◆ PgStat_BgWriterStats

◆ PgStat_BktypeIO

◆ PgStat_CheckpointerStats

◆ PgStat_Counter

typedef int64 PgStat_Counter

Definition at line 89 of file pgstat.h.

◆ PgStat_FetchConsistency

◆ PgStat_FunctionCallUsage

◆ PgStat_FunctionCounts

◆ PgStat_IO

typedef struct PgStat_IO PgStat_IO

◆ PgStat_Kind

typedef enum PgStat_Kind PgStat_Kind

◆ PgStat_PendingWalStats

◆ PgStat_SLRUStats

◆ PgStat_StatDBEntry

◆ PgStat_StatFuncEntry

◆ PgStat_StatReplSlotEntry

◆ PgStat_StatSubEntry

◆ PgStat_StatTabEntry

◆ PgStat_TableCounts

◆ PgStat_TableStatus

◆ PgStat_TableXactStatus

◆ PgStat_WalStats

◆ SessionEndType

◆ TrackFunctionsLevel

Enumeration Type Documentation

◆ IOContext

enum IOContext
Enumerator
IOCONTEXT_BULKREAD 
IOCONTEXT_BULKWRITE 
IOCONTEXT_NORMAL 
IOCONTEXT_VACUUM 

Definition at line 286 of file pgstat.h.

287 {
292 } IOContext;
IOContext
Definition: pgstat.h:287
@ IOCONTEXT_NORMAL
Definition: pgstat.h:290
@ IOCONTEXT_VACUUM
Definition: pgstat.h:291
@ IOCONTEXT_BULKREAD
Definition: pgstat.h:288
@ IOCONTEXT_BULKWRITE
Definition: pgstat.h:289

◆ IOObject

enum IOObject
Enumerator
IOOBJECT_RELATION 
IOOBJECT_TEMP_RELATION 

Definition at line 278 of file pgstat.h.

279 {
282 } IOObject;
IOObject
Definition: pgstat.h:279
@ IOOBJECT_RELATION
Definition: pgstat.h:280
@ IOOBJECT_TEMP_RELATION
Definition: pgstat.h:281

◆ IOOp

enum IOOp
Enumerator
IOOP_EVICT 
IOOP_EXTEND 
IOOP_FSYNC 
IOOP_HIT 
IOOP_READ 
IOOP_REUSE 
IOOP_WRITE 
IOOP_WRITEBACK 

Definition at line 296 of file pgstat.h.

297 {
298  IOOP_EVICT,
299  IOOP_EXTEND,
300  IOOP_FSYNC,
301  IOOP_HIT,
302  IOOP_READ,
303  IOOP_REUSE,
304  IOOP_WRITE,
306 } IOOp;
IOOp
Definition: pgstat.h:297
@ IOOP_EXTEND
Definition: pgstat.h:299
@ IOOP_FSYNC
Definition: pgstat.h:300
@ IOOP_READ
Definition: pgstat.h:302
@ IOOP_WRITEBACK
Definition: pgstat.h:305
@ IOOP_HIT
Definition: pgstat.h:301
@ IOOP_EVICT
Definition: pgstat.h:298
@ IOOP_REUSE
Definition: pgstat.h:303
@ IOOP_WRITE
Definition: pgstat.h:304

◆ PgStat_FetchConsistency

Enumerator
PGSTAT_FETCH_CONSISTENCY_NONE 
PGSTAT_FETCH_CONSISTENCY_CACHE 
PGSTAT_FETCH_CONSISTENCY_SNAPSHOT 

Definition at line 68 of file pgstat.h.

69 {
PgStat_FetchConsistency
Definition: pgstat.h:69
@ PGSTAT_FETCH_CONSISTENCY_NONE
Definition: pgstat.h:70
@ PGSTAT_FETCH_CONSISTENCY_CACHE
Definition: pgstat.h:71
@ PGSTAT_FETCH_CONSISTENCY_SNAPSHOT
Definition: pgstat.h:72

◆ PgStat_Kind

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

Definition at line 35 of file pgstat.h.

36 {
37  /* use 0 for INVALID, to catch zero-initialized data */
39 
40  /* stats for variable-numbered objects */
41  PGSTAT_KIND_DATABASE, /* database-wide statistics */
42  PGSTAT_KIND_RELATION, /* per-table statistics */
43  PGSTAT_KIND_FUNCTION, /* per-function statistics */
44  PGSTAT_KIND_REPLSLOT, /* per-slot statistics */
45  PGSTAT_KIND_SUBSCRIPTION, /* per-subscription statistics */
46 
47  /* stats for fixed-numbered objects */
54 } PgStat_Kind;
PgStat_Kind
Definition: pgstat.h:36
@ PGSTAT_KIND_DATABASE
Definition: pgstat.h:41
@ PGSTAT_KIND_REPLSLOT
Definition: pgstat.h:44
@ PGSTAT_KIND_ARCHIVER
Definition: pgstat.h:48
@ PGSTAT_KIND_SLRU
Definition: pgstat.h:52
@ PGSTAT_KIND_IO
Definition: pgstat.h:51
@ PGSTAT_KIND_BGWRITER
Definition: pgstat.h:49
@ PGSTAT_KIND_INVALID
Definition: pgstat.h:38
@ PGSTAT_KIND_SUBSCRIPTION
Definition: pgstat.h:45
@ PGSTAT_KIND_CHECKPOINTER
Definition: pgstat.h:50
@ PGSTAT_KIND_FUNCTION
Definition: pgstat.h:43
@ PGSTAT_KIND_WAL
Definition: pgstat.h:53
@ PGSTAT_KIND_RELATION
Definition: pgstat.h:42

◆ SessionEndType

Enumerator
DISCONNECT_NOT_YET 
DISCONNECT_NORMAL 
DISCONNECT_CLIENT_EOF 
DISCONNECT_FATAL 
DISCONNECT_KILLED 

Definition at line 76 of file pgstat.h.

77 {
78  DISCONNECT_NOT_YET, /* still active */
SessionEndType
Definition: pgstat.h:77
@ DISCONNECT_NOT_YET
Definition: pgstat.h:78
@ DISCONNECT_FATAL
Definition: pgstat.h:81
@ DISCONNECT_KILLED
Definition: pgstat.h:82
@ DISCONNECT_CLIENT_EOF
Definition: pgstat.h:80
@ DISCONNECT_NORMAL
Definition: pgstat.h:79

◆ TrackFunctionsLevel

Enumerator
TRACK_FUNC_OFF 
TRACK_FUNC_PL 
TRACK_FUNC_ALL 

Definition at line 61 of file pgstat.h.

62 {
TrackFunctionsLevel
Definition: pgstat.h:62
@ TRACK_FUNC_PL
Definition: pgstat.h:64
@ TRACK_FUNC_ALL
Definition: pgstat.h:65
@ TRACK_FUNC_OFF
Definition: pgstat.h:63

Function Documentation

◆ AtEOSubXact_PgStat()

void AtEOSubXact_PgStat ( bool  isCommit,
int  nestDepth 
)

Definition at line 112 of file pgstat_xact.c.

113 {
114  PgStat_SubXactStatus *xact_state;
115 
116  /* merge the sub-transaction's transactional stats into the parent */
117  xact_state = pgStatXactStack;
118  if (xact_state != NULL &&
119  xact_state->nest_level >= nestDepth)
120  {
121  /* delink xact_state from stack immediately to simplify reuse case */
122  pgStatXactStack = xact_state->prev;
123 
124  AtEOSubXact_PgStat_Relations(xact_state, isCommit, nestDepth);
125  AtEOSubXact_PgStat_DroppedStats(xact_state, isCommit, nestDepth);
126 
127  pfree(xact_state);
128  }
129 }
void pfree(void *pointer)
Definition: mcxt.c:1520
void AtEOSubXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit, int nestDepth)
static PgStat_SubXactStatus * pgStatXactStack
Definition: pgstat_xact.c:33
static void AtEOSubXact_PgStat_DroppedStats(PgStat_SubXactStatus *xact_state, bool isCommit, int nestDepth)
Definition: pgstat_xact.c:135
struct PgStat_SubXactStatus * prev

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

Referenced by AbortSubTransaction(), and CommitSubTransaction().

◆ AtEOXact_PgStat()

void AtEOXact_PgStat ( bool  isCommit,
bool  parallel 
)

Definition at line 40 of file pgstat_xact.c.

41 {
42  PgStat_SubXactStatus *xact_state;
43 
44  AtEOXact_PgStat_Database(isCommit, parallel);
45 
46  /* handle transactional stats information */
47  xact_state = pgStatXactStack;
48  if (xact_state != NULL)
49  {
50  Assert(xact_state->nest_level == 1);
51  Assert(xact_state->prev == NULL);
52 
53  AtEOXact_PgStat_Relations(xact_state, isCommit);
54  AtEOXact_PgStat_DroppedStats(xact_state, isCommit);
55  }
56  pgStatXactStack = NULL;
57 
58  /* Make sure any stats snapshot is thrown away */
60 }
#define Assert(condition)
Definition: c.h:858
void pgstat_clear_snapshot(void)
Definition: pgstat.c:782
void AtEOXact_PgStat_Database(bool isCommit, bool parallel)
void AtEOXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit)
static void AtEOXact_PgStat_DroppedStats(PgStat_SubXactStatus *xact_state, bool isCommit)
Definition: pgstat_xact.c:67

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

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

◆ AtPrepare_PgStat()

void AtPrepare_PgStat ( void  )

Definition at line 189 of file pgstat_xact.c.

190 {
191  PgStat_SubXactStatus *xact_state;
192 
193  xact_state = pgStatXactStack;
194  if (xact_state != NULL)
195  {
196  Assert(xact_state->nest_level == 1);
197  Assert(xact_state->prev == NULL);
198 
199  AtPrepare_PgStat_Relations(xact_state);
200  }
201 }
void AtPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state)

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

Referenced by PrepareTransaction().

◆ find_funcstat_entry()

PgStat_FunctionCounts* find_funcstat_entry ( Oid  func_id)

Definition at line 223 of file pgstat_function.c.

224 {
225  PgStat_EntryRef *entry_ref;
226 
228 
229  if (entry_ref)
230  return entry_ref->pending;
231  return NULL;
232 }
Oid MyDatabaseId
Definition: globals.c:91
PgStat_EntryRef * pgstat_fetch_pending_entry(PgStat_Kind kind, Oid dboid, Oid objoid)
Definition: pgstat.c:1143

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

Referenced by pg_stat_get_xact_function_calls().

◆ find_tabstat_entry()

PgStat_TableStatus* find_tabstat_entry ( Oid  rel_id)

Definition at line 487 of file pgstat_relation.c.

488 {
489  PgStat_EntryRef *entry_ref;
491  PgStat_TableStatus *tabentry = NULL;
492  PgStat_TableStatus *tablestatus = NULL;
493 
495  if (!entry_ref)
496  {
498  if (!entry_ref)
499  return tablestatus;
500  }
501 
502  tabentry = (PgStat_TableStatus *) entry_ref->pending;
503  tablestatus = palloc(sizeof(PgStat_TableStatus));
504  *tablestatus = *tabentry;
505 
506  /*
507  * Reset tablestatus->trans in the copy of PgStat_TableStatus as it may
508  * point to a shared memory area. Its data is saved below, so removing it
509  * does not matter.
510  */
511  tablestatus->trans = NULL;
512 
513  /*
514  * Live subtransaction counts are not included yet. This is not a hot
515  * code path so reconcile tuples_inserted, tuples_updated and
516  * tuples_deleted even if the caller may not be interested in this data.
517  */
518  for (trans = tabentry->trans; trans != NULL; trans = trans->upper)
519  {
520  tablestatus->counts.tuples_inserted += trans->tuples_inserted;
521  tablestatus->counts.tuples_updated += trans->tuples_updated;
522  tablestatus->counts.tuples_deleted += trans->tuples_deleted;
523  }
524 
525  return tablestatus;
526 }
void * palloc(Size size)
Definition: mcxt.c:1316
#define InvalidOid
Definition: postgres_ext.h:36
PgStat_Counter tuples_inserted
Definition: pgstat.h:167
PgStat_Counter tuples_updated
Definition: pgstat.h:168
PgStat_Counter tuples_deleted
Definition: pgstat.h:169
PgStat_TableCounts counts
Definition: pgstat.h:202
struct PgStat_TableXactStatus * trans
Definition: pgstat.h:201
static zic_t trans[TZ_MAX_LEAPS]
Definition: zic.c:402

References PgStat_TableStatus::counts, InvalidOid, MyDatabaseId, palloc(), PgStat_EntryRef::pending, pgstat_fetch_pending_entry(), PGSTAT_KIND_RELATION, PgStat_TableStatus::trans, trans, PgStat_TableCounts::tuples_deleted, PgStat_TableCounts::tuples_inserted, and PgStat_TableCounts::tuples_updated.

◆ pgstat_acquire_replslot()

void pgstat_acquire_replslot ( struct ReplicationSlot slot)

Definition at line 146 of file pgstat_replslot.c.

147 {
149  ReplicationSlotIndex(slot), true, NULL);
150 }
PgStat_EntryRef * pgstat_get_entry_ref(PgStat_Kind kind, Oid dboid, Oid objoid, bool create, bool *created_entry)
Definition: pgstat_shmem.c:398
int ReplicationSlotIndex(ReplicationSlot *slot)
Definition: slot.c:497

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

Referenced by ReplicationSlotAcquire().

◆ pgstat_assoc_relation()

void pgstat_assoc_relation ( Relation  rel)

Definition at line 132 of file pgstat_relation.c.

133 {
134  Assert(rel->pgstat_enabled);
135  Assert(rel->pgstat_info == NULL);
136 
137  /* Else find or make the PgStat_TableStatus entry, and update link */
139  rel->rd_rel->relisshared);
140 
141  /* don't allow link a stats to multiple relcache entries */
142  Assert(rel->pgstat_info->relation == NULL);
143 
144  /* mark this relation as the owner */
145  rel->pgstat_info->relation = rel;
146 }
static PgStat_TableStatus * pgstat_prep_relation_pending(Oid rel_id, bool isshared)
#define RelationGetRelid(relation)
Definition: rel.h:505
Relation relation
Definition: pgstat.h:203
bool pgstat_enabled
Definition: rel.h:253
Form_pg_class rd_rel
Definition: rel.h:111
struct PgStat_TableStatus * pgstat_info
Definition: rel.h:255

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

◆ pgstat_before_server_shutdown()

void pgstat_before_server_shutdown ( int  code,
Datum  arg 
)

Definition at line 462 of file pgstat.c.

463 {
464  Assert(pgStatLocal.shmem != NULL);
466 
467  /*
468  * Stats should only be reported after pgstat_initialize() and before
469  * pgstat_shutdown(). This is a convenient point to catch most violations
470  * of this rule.
471  */
472  Assert(pgstat_is_initialized && !pgstat_is_shutdown);
473 
474  /* flush out our own pending changes before writing out */
475  pgstat_report_stat(true);
476 
477  /*
478  * Only write out file during normal shutdown. Don't even signal that
479  * we've shutdown during irregular shutdowns, because the shutdown
480  * sequence isn't coordinated to ensure this backend shuts down last.
481  */
482  if (code == 0)
483  {
484  pgStatLocal.shmem->is_shutdown = true;
486  }
487 }
static void pgstat_write_statsfile(void)
Definition: pgstat.c:1308
long pgstat_report_stat(bool force)
Definition: pgstat.c:579
PgStat_LocalState pgStatLocal
Definition: pgstat.c:193
PgStat_ShmemControl * shmem

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

Referenced by CheckpointerMain(), and InitPostgres().

◆ pgstat_bktype_io_stats_valid()

bool pgstat_bktype_io_stats_valid ( PgStat_BktypeIO backend_io,
BackendType  bktype 
)

Definition at line 46 of file pgstat_io.c.

48 {
49  for (int io_object = 0; io_object < IOOBJECT_NUM_TYPES; io_object++)
50  {
51  for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++)
52  {
53  for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++)
54  {
55  /* we do track it */
56  if (pgstat_tracks_io_op(bktype, io_object, io_context, io_op))
57  {
58  /* ensure that if IO times are non-zero, counts are > 0 */
59  if (backend_io->times[io_object][io_context][io_op] != 0 &&
60  backend_io->counts[io_object][io_context][io_op] <= 0)
61  return false;
62 
63  continue;
64  }
65 
66  /* we don't track it, and it is not 0 */
67  if (backend_io->counts[io_object][io_context][io_op] != 0)
68  return false;
69  }
70  }
71  }
72 
73  return true;
74 }
#define IOOP_NUM_TYPES
Definition: pgstat.h:308
#define IOCONTEXT_NUM_TYPES
Definition: pgstat.h:294
#define IOOBJECT_NUM_TYPES
Definition: pgstat.h:284
bool pgstat_tracks_io_op(BackendType bktype, IOObject io_object, IOContext io_context, IOOp io_op)
Definition: pgstat_io.c:424
PgStat_Counter times[IOOBJECT_NUM_TYPES][IOCONTEXT_NUM_TYPES][IOOP_NUM_TYPES]
Definition: pgstat.h:313
PgStat_Counter counts[IOOBJECT_NUM_TYPES][IOCONTEXT_NUM_TYPES][IOOP_NUM_TYPES]
Definition: pgstat.h:312

References PgStat_BktypeIO::counts, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, pgstat_tracks_io_op(), and PgStat_BktypeIO::times.

Referenced by pg_stat_get_io(), and pgstat_flush_io().

◆ pgstat_clear_snapshot()

void pgstat_clear_snapshot ( void  )

Definition at line 782 of file pgstat.c.

783 {
785 
786  memset(&pgStatLocal.snapshot.fixed_valid, 0,
788  pgStatLocal.snapshot.stats = NULL;
790 
791  /* Release memory, if any was allocated */
793  {
795 
796  /* Reset variables */
798  }
799 
800  /*
801  * Historically the backend_status.c facilities lived in this file, and
802  * were reset with the same function. For now keep it that way, and
803  * forward the reset request.
804  */
806 
807  /* Reset this flag, as it may be possible that a cleanup was forced. */
809 }
void pgstat_clear_backend_activity_snapshot(void)
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:454
static bool force_stats_snapshot_clear
Definition: pgstat.c:231
#define pgstat_assert_is_up()
PgStat_Snapshot snapshot
MemoryContext context
bool fixed_valid[PGSTAT_NUM_KINDS]
PgStat_FetchConsistency mode
struct pgstat_snapshot_hash * stats

References PgStat_Snapshot::context, 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 
)

Definition at line 58 of file pgstat_relation.c.

59 {
60  PgStat_StatTabEntry *srcstats;
61  PgStatShared_Relation *dstshstats;
62  PgStat_EntryRef *dst_ref;
63 
64  srcstats = pgstat_fetch_stat_tabentry_ext(src->rd_rel->relisshared,
65  RelationGetRelid(src));
66  if (!srcstats)
67  return;
68 
70  dst->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
71  RelationGetRelid(dst),
72  false);
73 
74  dstshstats = (PgStatShared_Relation *) dst_ref->shared_stats;
75  dstshstats->stats = *srcstats;
76 
77  pgstat_unlock_entry(dst_ref);
78 }
PgStat_StatTabEntry * pgstat_fetch_stat_tabentry_ext(bool shared, Oid reloid)
void pgstat_unlock_entry(PgStat_EntryRef *entry_ref)
Definition: pgstat_shmem.c:604
PgStat_EntryRef * pgstat_get_entry_ref_locked(PgStat_Kind kind, Oid dboid, Oid objoid, bool nowait)
Definition: pgstat_shmem.c:613
PgStat_StatTabEntry stats
PgStatShared_Common * shared_stats

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

Referenced by index_concurrently_swap().

◆ pgstat_count_heap_delete()

void pgstat_count_heap_delete ( Relation  rel)

Definition at line 401 of file pgstat_relation.c.

402 {
404  {
405  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
406 
407  ensure_tabstat_xact_level(pgstat_info);
408  pgstat_info->trans->tuples_deleted++;
409  }
410 }
static void ensure_tabstat_xact_level(PgStat_TableStatus *pgstat_info)
PgStat_Counter tuples_deleted
Definition: pgstat.h:214

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

Referenced by heap_abort_speculative(), and heap_delete().

◆ pgstat_count_heap_insert()

void pgstat_count_heap_insert ( Relation  rel,
PgStat_Counter  n 
)

Definition at line 360 of file pgstat_relation.c.

361 {
363  {
364  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
365 
366  ensure_tabstat_xact_level(pgstat_info);
367  pgstat_info->trans->tuples_inserted += n;
368  }
369 }
PgStat_Counter tuples_inserted
Definition: pgstat.h:212

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

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

◆ pgstat_count_heap_update()

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

Definition at line 375 of file pgstat_relation.c.

376 {
377  Assert(!(hot && newpage));
378 
380  {
381  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
382 
383  ensure_tabstat_xact_level(pgstat_info);
384  pgstat_info->trans->tuples_updated++;
385 
386  /*
387  * tuples_hot_updated and tuples_newpage_updated counters are
388  * nontransactional, so just advance them
389  */
390  if (hot)
391  pgstat_info->counts.tuples_hot_updated++;
392  else if (newpage)
393  pgstat_info->counts.tuples_newpage_updated++;
394  }
395 }
PgStat_Counter tuples_hot_updated
Definition: pgstat.h:170
PgStat_Counter tuples_newpage_updated
Definition: pgstat.h:171
PgStat_Counter tuples_updated
Definition: pgstat.h:213

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

Referenced by heap_update().

◆ pgstat_count_io_op()

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

Definition at line 77 of file pgstat_io.c.

78 {
79  pgstat_count_io_op_n(io_object, io_context, io_op, 1);
80 }
void pgstat_count_io_op_n(IOObject io_object, IOContext io_context, IOOp io_op, uint32 cnt)
Definition: pgstat_io.c:83

References pgstat_count_io_op_n().

Referenced by GetLocalVictimBuffer(), GetVictimBuffer(), and PinBufferForBlock().

◆ pgstat_count_io_op_n()

void pgstat_count_io_op_n ( IOObject  io_object,
IOContext  io_context,
IOOp  io_op,
uint32  cnt 
)

Definition at line 83 of file pgstat_io.c.

84 {
85  Assert((unsigned int) io_object < IOOBJECT_NUM_TYPES);
86  Assert((unsigned int) io_context < IOCONTEXT_NUM_TYPES);
87  Assert((unsigned int) io_op < IOOP_NUM_TYPES);
88  Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
89 
90  PendingIOStats.counts[io_object][io_context][io_op] += cnt;
91 
92  have_iostats = true;
93 }
BackendType MyBackendType
Definition: miscinit.c:63
static PgStat_PendingIO PendingIOStats
Definition: pgstat_io.c:31
bool have_iostats
Definition: pgstat_io.c:32
PgStat_Counter counts[IOOBJECT_NUM_TYPES][IOCONTEXT_NUM_TYPES][IOOP_NUM_TYPES]
Definition: pgstat_io.c:26

References Assert, PgStat_PendingIO::counts, have_iostats, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, MyBackendType, PendingIOStats, and pgstat_tracks_io_op().

Referenced by pgstat_count_io_op(), and pgstat_count_io_op_time().

◆ 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 
)

Definition at line 122 of file pgstat_io.c.

124 {
125  if (track_io_timing)
126  {
127  instr_time io_time;
128 
129  INSTR_TIME_SET_CURRENT(io_time);
131 
132  if (io_op == IOOP_WRITE || io_op == IOOP_EXTEND)
133  {
135  if (io_object == IOOBJECT_RELATION)
137  else if (io_object == IOOBJECT_TEMP_RELATION)
139  }
140  else if (io_op == IOOP_READ)
141  {
143  if (io_object == IOOBJECT_RELATION)
145  else if (io_object == IOOBJECT_TEMP_RELATION)
147  }
148 
149  INSTR_TIME_ADD(PendingIOStats.pending_times[io_object][io_context][io_op],
150  io_time);
151  }
152 
153  pgstat_count_io_op_n(io_object, io_context, io_op, cnt);
154 }
bool track_io_timing
Definition: bufmgr.c:142
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:122
#define INSTR_TIME_ADD(x, y)
Definition: instr_time.h:178
#define INSTR_TIME_SUBTRACT(x, y)
Definition: instr_time.h:181
#define INSTR_TIME_GET_MICROSEC(t)
Definition: instr_time.h:194
BufferUsage pgBufferUsage
Definition: instrument.c:20
static time_t start_time
Definition: pg_ctl.c:94
#define pgstat_count_buffer_read_time(n)
Definition: pgstat.h:552
#define pgstat_count_buffer_write_time(n)
Definition: pgstat.h:554
instr_time local_blk_read_time
Definition: instrument.h:38
instr_time shared_blk_read_time
Definition: instrument.h:36
instr_time shared_blk_write_time
Definition: instrument.h:37
instr_time local_blk_write_time
Definition: instrument.h:39
instr_time pending_times[IOOBJECT_NUM_TYPES][IOCONTEXT_NUM_TYPES][IOOP_NUM_TYPES]
Definition: pgstat_io.c:27

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

Referenced by ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushBuffer(), FlushRelationBuffers(), GetLocalVictimBuffer(), IssuePendingWritebacks(), mdsyncfiletag(), register_dirty_segment(), and WaitReadBuffers().

◆ pgstat_count_slru_flush()

void pgstat_count_slru_flush ( int  slru_idx)

Definition at line 89 of file pgstat_slru.c.

90 {
91  get_slru_entry(slru_idx)->flush += 1;
92 }
static PgStat_SLRUStats * get_slru_entry(int slru_idx)
Definition: pgstat_slru.c:220
PgStat_Counter flush
Definition: pgstat.h:387

References PgStat_SLRUStats::flush, and get_slru_entry().

Referenced by SimpleLruWriteAll().

◆ pgstat_count_slru_page_exists()

void pgstat_count_slru_page_exists ( int  slru_idx)

Definition at line 71 of file pgstat_slru.c.

72 {
73  get_slru_entry(slru_idx)->blocks_exists += 1;
74 }
PgStat_Counter blocks_exists
Definition: pgstat.h:386

References PgStat_SLRUStats::blocks_exists, and get_slru_entry().

Referenced by SimpleLruDoesPhysicalPageExist().

◆ pgstat_count_slru_page_hit()

void pgstat_count_slru_page_hit ( int  slru_idx)

Definition at line 65 of file pgstat_slru.c.

66 {
67  get_slru_entry(slru_idx)->blocks_hit += 1;
68 }
PgStat_Counter blocks_hit
Definition: pgstat.h:383

References PgStat_SLRUStats::blocks_hit, and get_slru_entry().

Referenced by SimpleLruReadPage(), and SimpleLruReadPage_ReadOnly().

◆ pgstat_count_slru_page_read()

void pgstat_count_slru_page_read ( int  slru_idx)

Definition at line 77 of file pgstat_slru.c.

78 {
79  get_slru_entry(slru_idx)->blocks_read += 1;
80 }
PgStat_Counter blocks_read
Definition: pgstat.h:384

References PgStat_SLRUStats::blocks_read, and get_slru_entry().

Referenced by SimpleLruReadPage().

◆ pgstat_count_slru_page_written()

void pgstat_count_slru_page_written ( int  slru_idx)

Definition at line 83 of file pgstat_slru.c.

84 {
85  get_slru_entry(slru_idx)->blocks_written += 1;
86 }
PgStat_Counter blocks_written
Definition: pgstat.h:385

References PgStat_SLRUStats::blocks_written, and get_slru_entry().

Referenced by SlruPhysicalWritePage().

◆ pgstat_count_slru_page_zeroed()

void pgstat_count_slru_page_zeroed ( int  slru_idx)

Definition at line 59 of file pgstat_slru.c.

60 {
61  get_slru_entry(slru_idx)->blocks_zeroed += 1;
62 }
PgStat_Counter blocks_zeroed
Definition: pgstat.h:382

References PgStat_SLRUStats::blocks_zeroed, and get_slru_entry().

Referenced by SimpleLruZeroPage().

◆ pgstat_count_slru_truncate()

void pgstat_count_slru_truncate ( int  slru_idx)

Definition at line 95 of file pgstat_slru.c.

96 {
97  get_slru_entry(slru_idx)->truncate += 1;
98 }
PgStat_Counter truncate
Definition: pgstat.h:388

References get_slru_entry(), and PgStat_SLRUStats::truncate.

Referenced by SimpleLruTruncate().

◆ pgstat_count_truncate()

void pgstat_count_truncate ( Relation  rel)

Definition at line 416 of file pgstat_relation.c.

417 {
419  {
420  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
421 
422  ensure_tabstat_xact_level(pgstat_info);
423  save_truncdrop_counters(pgstat_info->trans, false);
424  pgstat_info->trans->tuples_inserted = 0;
425  pgstat_info->trans->tuples_updated = 0;
426  pgstat_info->trans->tuples_deleted = 0;
427  }
428 }
static void save_truncdrop_counters(PgStat_TableXactStatus *trans, bool is_drop)

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

Referenced by ExecRefreshMatView(), and ExecuteTruncateGuts().

◆ pgstat_create_function()

void pgstat_create_function ( Oid  proid)

Definition at line 45 of file pgstat_function.c.

46 {
49  proid);
50 }
void pgstat_create_transactional(PgStat_Kind kind, Oid dboid, Oid objoid)
Definition: pgstat_xact.c:357

References MyDatabaseId, pgstat_create_transactional(), and PGSTAT_KIND_FUNCTION.

Referenced by ProcedureCreate().

◆ pgstat_create_relation()

void pgstat_create_relation ( Relation  rel)

◆ pgstat_create_replslot()

void pgstat_create_replslot ( struct ReplicationSlot slot)

Definition at line 111 of file pgstat_replslot.c.

112 {
113  PgStat_EntryRef *entry_ref;
114  PgStatShared_ReplSlot *shstatent;
115 
116  Assert(LWLockHeldByMeInMode(ReplicationSlotAllocationLock, LW_EXCLUSIVE));
117 
119  ReplicationSlotIndex(slot), false);
120  shstatent = (PgStatShared_ReplSlot *) entry_ref->shared_stats;
121 
122  /*
123  * NB: need to accept that there might be stats from an older slot, e.g.
124  * if we previously crashed after dropping a slot.
125  */
126  memset(&shstatent->stats, 0, sizeof(shstatent->stats));
127 
128  pgstat_unlock_entry(entry_ref);
129 }
bool LWLockHeldByMeInMode(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1939
@ LW_EXCLUSIVE
Definition: lwlock.h:114
PgStat_StatReplSlotEntry stats

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

Referenced by ReplicationSlotCreate().

◆ pgstat_create_subscription()

void pgstat_create_subscription ( Oid  subid)

Definition at line 46 of file pgstat_subscription.c.

47 {
48  /* Ensures that stats are dropped if transaction rolls back */
50  InvalidOid, subid);
51 
52  /* Create and initialize the subscription stats entry */
54  true, NULL);
56 }
void pgstat_reset_entry(PgStat_Kind kind, Oid dboid, Oid objoid, TimestampTz ts)
Definition: pgstat_shmem.c:949

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

Referenced by CreateSubscription().

◆ pgstat_discard_stats()

void pgstat_discard_stats ( void  )

Definition at line 419 of file pgstat.c.

420 {
421  int ret;
422 
423  /* NB: this needs to be done even in single user mode */
424 
425  ret = unlink(PGSTAT_STAT_PERMANENT_FILENAME);
426  if (ret != 0)
427  {
428  if (errno == ENOENT)
429  elog(DEBUG2,
430  "didn't need to unlink permanent stats file \"%s\" - didn't exist",
432  else
433  ereport(LOG,
435  errmsg("could not unlink permanent statistics file \"%s\": %m",
437  }
438  else
439  {
440  ereport(DEBUG2,
442  errmsg_internal("unlinked permanent statistics file \"%s\"",
444  }
445 
446  /*
447  * Reset stats contents. This will set reset timestamps of fixed-numbered
448  * stats to the current time (no variable stats exist).
449  */
451 }
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1157
int errcode_for_file_access(void)
Definition: elog.c:880
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define LOG
Definition: elog.h:31
#define DEBUG2
Definition: elog.h:29
#define elog(elevel,...)
Definition: elog.h:224
#define ereport(elevel,...)
Definition: elog.h:149
static void pgstat_reset_after_failure(void)
Definition: pgstat.c:1684
#define PGSTAT_STAT_PERMANENT_FILENAME
Definition: pgstat.h:28

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

Referenced by StartupXLOG().

◆ pgstat_drop_database()

void pgstat_drop_database ( Oid  databaseid)

Definition at line 44 of file pgstat_database.c.

45 {
47 }
void pgstat_drop_transactional(PgStat_Kind kind, Oid dboid, Oid objoid)
Definition: pgstat_xact.c:379

References InvalidOid, pgstat_drop_transactional(), and PGSTAT_KIND_DATABASE.

Referenced by dropdb().

◆ pgstat_drop_function()

void pgstat_drop_function ( Oid  proid)

Definition at line 60 of file pgstat_function.c.

61 {
64  proid);
65 }

References MyDatabaseId, pgstat_drop_transactional(), and PGSTAT_KIND_FUNCTION.

Referenced by RemoveFunctionById().

◆ pgstat_drop_relation()

void pgstat_drop_relation ( Relation  rel)

Definition at line 180 of file pgstat_relation.c.

181 {
182  int nest_level = GetCurrentTransactionNestLevel();
183  PgStat_TableStatus *pgstat_info;
184 
186  rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId,
187  RelationGetRelid(rel));
188 
190  return;
191 
192  /*
193  * Transactionally set counters to 0. That ensures that accesses to
194  * pg_stat_xact_all_tables inside the transaction show 0.
195  */
196  pgstat_info = rel->pgstat_info;
197  if (pgstat_info->trans &&
198  pgstat_info->trans->nest_level == nest_level)
199  {
200  save_truncdrop_counters(pgstat_info->trans, true);
201  pgstat_info->trans->tuples_inserted = 0;
202  pgstat_info->trans->tuples_updated = 0;
203  pgstat_info->trans->tuples_deleted = 0;
204  }
205 }
int GetCurrentTransactionNestLevel(void)
Definition: xact.c:926

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

Referenced by heap_drop_with_catalog(), and index_drop().

◆ pgstat_drop_replslot()

void pgstat_drop_replslot ( struct ReplicationSlot slot)

Definition at line 156 of file pgstat_replslot.c.

157 {
158  Assert(LWLockHeldByMeInMode(ReplicationSlotAllocationLock, LW_EXCLUSIVE));
159 
161  ReplicationSlotIndex(slot)))
163 }
void pgstat_request_entry_refs_gc(void)
Definition: pgstat_shmem.c:629
bool pgstat_drop_entry(PgStat_Kind kind, Oid dboid, Oid objoid)
Definition: pgstat_shmem.c:874

References Assert, 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)

◆ pgstat_end_function_usage()

void pgstat_end_function_usage ( PgStat_FunctionCallUsage fcu,
bool  finalize 
)

Definition at line 146 of file pgstat_function.c.

147 {
148  PgStat_FunctionCounts *fs = fcu->fs;
149  instr_time total;
150  instr_time others;
151  instr_time self;
152 
153  /* stats not wanted? */
154  if (fs == NULL)
155  return;
156 
157  /* total elapsed time in this function call */
158  INSTR_TIME_SET_CURRENT(total);
159  INSTR_TIME_SUBTRACT(total, fcu->start);
160 
161  /* self usage: elapsed minus anything already charged to other calls */
162  others = total_func_time;
163  INSTR_TIME_SUBTRACT(others, fcu->save_total);
164  self = total;
165  INSTR_TIME_SUBTRACT(self, others);
166 
167  /* update backend-wide total time */
169 
170  /*
171  * Compute the new total_time as the total elapsed time added to the
172  * pre-call value of total_time. This is necessary to avoid
173  * double-counting any time taken by recursive calls of myself. (We do
174  * not need any similar kluge for self time, since that already excludes
175  * any recursive calls.)
176  */
177  INSTR_TIME_ADD(total, fcu->save_f_total_time);
178 
179  /* update counters in function stats table */
180  if (finalize)
181  fs->numcalls++;
182  fs->total_time = total;
183  INSTR_TIME_ADD(fs->self_time, self);
184 }
static instr_time total_func_time
instr_time save_total
Definition: pgstat.h:125
PgStat_FunctionCounts * fs
Definition: pgstat.h:121
instr_time save_f_total_time
Definition: pgstat.h:123
PgStat_Counter numcalls
Definition: pgstat.h:109
instr_time total_time
Definition: pgstat.h:110
instr_time self_time
Definition: pgstat.h:111

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

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

◆ pgstat_execute_transactional_drops()

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

Definition at line 312 of file pgstat_xact.c.

313 {
314  int not_freed_count = 0;
315 
316  if (ndrops == 0)
317  return;
318 
319  for (int i = 0; i < ndrops; i++)
320  {
321  xl_xact_stats_item *it = &items[i];
322 
323  if (!pgstat_drop_entry(it->kind, it->dboid, it->objoid))
324  not_freed_count++;
325  }
326 
327  if (not_freed_count > 0)
329 }
int i
Definition: isn.c:73
static ItemArray items
Definition: test_tidstore.c:49

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

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

◆ pgstat_fetch_replslot()

PgStat_StatReplSlotEntry* pgstat_fetch_replslot ( NameData  slotname)

Definition at line 170 of file pgstat_replslot.c.

171 {
172  int idx;
173  PgStat_StatReplSlotEntry *slotentry = NULL;
174 
175  LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
176 
177  idx = get_replslot_index(NameStr(slotname), false);
178 
179  if (idx != -1)
181  InvalidOid, idx);
182 
183  LWLockRelease(ReplicationSlotControlLock);
184 
185  return slotentry;
186 }
Datum idx(PG_FUNCTION_ARGS)
Definition: _int_op.c:259
#define NameStr(name)
Definition: c.h:746
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1170
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1783
@ LW_SHARED
Definition: lwlock.h:115
void * pgstat_fetch_entry(PgStat_Kind kind, Oid dboid, Oid objoid)
Definition: pgstat.c:812
static int get_replslot_index(const char *name, bool need_lock)

References 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  )

Definition at line 105 of file pgstat_slru.c.

106 {
108 
109  return pgStatLocal.snapshot.slru;
110 }
void pgstat_snapshot_fixed(PgStat_Kind kind)
Definition: pgstat.c:938
PgStat_SLRUStats slru[SLRU_NUM_ELEMENTS]

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  )

◆ pgstat_fetch_stat_bgwriter()

◆ pgstat_fetch_stat_checkpointer()

◆ pgstat_fetch_stat_dbentry()

◆ pgstat_fetch_stat_funcentry()

PgStat_StatFuncEntry* pgstat_fetch_stat_funcentry ( Oid  func_id)

◆ pgstat_fetch_stat_io()

PgStat_IO* pgstat_fetch_stat_io ( void  )

◆ pgstat_fetch_stat_subscription()

PgStat_StatSubEntry* pgstat_fetch_stat_subscription ( Oid  subid)

◆ pgstat_fetch_stat_tabentry()

PgStat_StatTabEntry* pgstat_fetch_stat_tabentry ( Oid  relid)

Definition at line 456 of file pgstat_relation.c.

457 {
458  return pgstat_fetch_stat_tabentry_ext(IsSharedRelation(relid), relid);
459 }
bool IsSharedRelation(Oid relationId)
Definition: catalog.c:243

References IsSharedRelation(), and pgstat_fetch_stat_tabentry_ext().

◆ pgstat_fetch_stat_tabentry_ext()

PgStat_StatTabEntry* pgstat_fetch_stat_tabentry_ext ( bool  shared,
Oid  reloid 
)

Definition at line 466 of file pgstat_relation.c.

467 {
468  Oid dboid = (shared ? InvalidOid : MyDatabaseId);
469 
470  return (PgStat_StatTabEntry *)
472 }
unsigned int Oid
Definition: postgres_ext.h:31

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

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

◆ pgstat_fetch_stat_wal()

PgStat_WalStats* pgstat_fetch_stat_wal ( void  )

◆ pgstat_force_next_flush()

void pgstat_force_next_flush ( void  )

Definition at line 694 of file pgstat.c.

695 {
696  pgStatForceNextFlush = true;
697 }
static bool pgStatForceNextFlush
Definition: pgstat.c:225

References pgStatForceNextFlush.

Referenced by pg_stat_force_next_flush().

◆ pgstat_get_io_context_name()

const char* pgstat_get_io_context_name ( IOContext  io_context)

Definition at line 221 of file pgstat_io.c.

222 {
223  switch (io_context)
224  {
225  case IOCONTEXT_BULKREAD:
226  return "bulkread";
227  case IOCONTEXT_BULKWRITE:
228  return "bulkwrite";
229  case IOCONTEXT_NORMAL:
230  return "normal";
231  case IOCONTEXT_VACUUM:
232  return "vacuum";
233  }
234 
235  elog(ERROR, "unrecognized IOContext value: %d", io_context);
236  pg_unreachable();
237 }
#define pg_unreachable()
Definition: c.h:296
#define ERROR
Definition: elog.h:39

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

Referenced by pg_stat_get_io().

◆ pgstat_get_io_object_name()

const char* pgstat_get_io_object_name ( IOObject  io_object)

Definition at line 240 of file pgstat_io.c.

241 {
242  switch (io_object)
243  {
244  case IOOBJECT_RELATION:
245  return "relation";
247  return "temp relation";
248  }
249 
250  elog(ERROR, "unrecognized IOObject value: %d", io_object);
251  pg_unreachable();
252 }

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

Referenced by pg_stat_get_io().

◆ pgstat_get_kind_from_str()

PgStat_Kind pgstat_get_kind_from_str ( char *  kind_str)

Definition at line 1242 of file pgstat.c.

1243 {
1244  for (int kind = PGSTAT_KIND_FIRST_VALID; kind <= PGSTAT_KIND_LAST; kind++)
1245  {
1246  if (pg_strcasecmp(kind_str, pgstat_kind_infos[kind].name) == 0)
1247  return kind;
1248  }
1249 
1250  ereport(ERROR,
1251  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1252  errmsg("invalid statistics kind: \"%s\"", kind_str)));
1253  return PGSTAT_KIND_DATABASE; /* avoid compiler warnings */
1254 }
int errcode(int sqlerrcode)
Definition: elog.c:857
static const PgStat_KindInfo pgstat_kind_infos[PGSTAT_NUM_KINDS]
Definition: pgstat.c:257
#define PGSTAT_KIND_LAST
Definition: pgstat.h:57
#define PGSTAT_KIND_FIRST_VALID
Definition: pgstat.h:56
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
const char * name

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

Referenced by pg_stat_have_stats().

◆ pgstat_get_slru_index()

int pgstat_get_slru_index ( const char *  name)

Definition at line 132 of file pgstat_slru.c.

133 {
134  int i;
135 
136  for (i = 0; i < SLRU_NUM_ELEMENTS; i++)
137  {
138  if (strcmp(slru_names[i], name) == 0)
139  return i;
140  }
141 
142  /* return index of the last entry (which is the "other" one) */
143  return (SLRU_NUM_ELEMENTS - 1);
144 }
static const char *const slru_names[]
#define SLRU_NUM_ELEMENTS

References i, name, slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pgstat_reset_slru(), and SimpleLruInit().

◆ pgstat_get_slru_name()

const char* pgstat_get_slru_name ( int  slru_idx)

Definition at line 118 of file pgstat_slru.c.

119 {
120  if (slru_idx < 0 || slru_idx >= SLRU_NUM_ELEMENTS)
121  return NULL;
122 
123  return slru_names[slru_idx];
124 }

References slru_names, and SLRU_NUM_ELEMENTS.

Referenced by pg_stat_get_slru().

◆ pgstat_get_stat_snapshot_timestamp()

TimestampTz pgstat_get_stat_snapshot_timestamp ( bool have_snapshot)

Definition at line 905 of file pgstat.c.

906 {
909 
911  {
912  *have_snapshot = true;
914  }
915 
916  *have_snapshot = false;
917 
918  return 0;
919 }
TimestampTz snapshot_timestamp

References 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 
)

Definition at line 270 of file pgstat_xact.c.

271 {
273  int nitems = 0;
274  dlist_iter iter;
275 
276  if (xact_state == NULL)
277  return 0;
278 
279  /*
280  * We expect to be called for subtransaction abort (which logs a WAL
281  * record), but not for subtransaction commit (which doesn't).
282  */
283  Assert(!isCommit || xact_state->nest_level == 1);
284  Assert(!isCommit || xact_state->prev == NULL);
285 
286  *items = palloc(dclist_count(&xact_state->pending_drops)
287  * sizeof(xl_xact_stats_item));
288 
289  dclist_foreach(iter, &xact_state->pending_drops)
290  {
293 
294  if (isCommit && pending->is_create)
295  continue;
296  if (!isCommit && !pending->is_create)
297  continue;
298 
299  Assert(nitems < dclist_count(&xact_state->pending_drops));
300  (*items)[nitems++] = pending->item;
301  }
302 
303  return nitems;
304 }
#define dclist_container(type, membername, ptr)
Definition: ilist.h:947
static uint32 dclist_count(const dclist_head *head)
Definition: ilist.h:932
#define dclist_foreach(iter, lhead)
Definition: ilist.h:970
#define nitems(x)
Definition: indent.h:31
xl_xact_stats_item item
Definition: pgstat_xact.c:23
dlist_node * cur
Definition: ilist.h:179

References Assert, dlist_iter::cur, dclist_container, dclist_count(), dclist_foreach, 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,
Oid  objoid 
)

Definition at line 922 of file pgstat.c.

923 {
924  /* fixed-numbered stats always exist */
925  if (pgstat_get_kind_info(kind)->fixed_amount)
926  return true;
927 
928  return pgstat_get_entry_ref(kind, dboid, objoid, false, NULL) != NULL;
929 }
const PgStat_KindInfo * pgstat_get_kind_info(PgStat_Kind kind)
Definition: pgstat.c:1263

References pgstat_get_entry_ref(), and pgstat_get_kind_info().

Referenced by pg_stat_have_stats().

◆ pgstat_init_function_usage()

void pgstat_init_function_usage ( struct FunctionCallInfoBaseData fcinfo,
PgStat_FunctionCallUsage fcu 
)

◆ pgstat_init_relation()

void pgstat_init_relation ( Relation  rel)

Definition at line 92 of file pgstat_relation.c.

93 {
94  char relkind = rel->rd_rel->relkind;
95 
96  /*
97  * We only count stats for relations with storage and partitioned tables
98  */
99  if (!RELKIND_HAS_STORAGE(relkind) && relkind != RELKIND_PARTITIONED_TABLE)
100  {
101  rel->pgstat_enabled = false;
102  rel->pgstat_info = NULL;
103  return;
104  }
105 
106  if (!pgstat_track_counts)
107  {
108  if (rel->pgstat_info)
110 
111  /* We're not counting at all */
112  rel->pgstat_enabled = false;
113  rel->pgstat_info = NULL;
114  return;
115  }
116 
117  rel->pgstat_enabled = true;
118 }
bool pgstat_track_counts
Definition: pgstat.c:184
void pgstat_unlink_relation(Relation rel)

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

Referenced by relation_open(), and try_relation_open().

◆ pgstat_initialize()

void pgstat_initialize ( void  )

Definition at line 537 of file pgstat.c.

538 {
539  Assert(!pgstat_is_initialized);
540 
542 
543  pgstat_init_wal();
544 
545  /* Set up a process-exit hook to clean up */
547 
548 #ifdef USE_ASSERT_CHECKING
549  pgstat_is_initialized = true;
550 #endif
551 }
void before_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:337
static void pgstat_shutdown_hook(int code, Datum arg)
Definition: pgstat.c:503
void pgstat_attach_shmem(void)
Definition: pgstat_shmem.c:218
void pgstat_init_wal(void)
Definition: pgstat_wal.c:141

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

Referenced by BaseInit().

◆ pgstat_prepare_io_time()

instr_time pgstat_prepare_io_time ( bool  track_io_guc)

Definition at line 100 of file pgstat_io.c.

101 {
102  instr_time io_start;
103 
104  if (track_io_guc)
105  INSTR_TIME_SET_CURRENT(io_start);
106  else
107  {
108  /*
109  * There is no need to set io_start when an IO timing GUC is disabled,
110  * still initialize it to zero to avoid compiler warnings.
111  */
112  INSTR_TIME_SET_ZERO(io_start);
113  }
114 
115  return io_start;
116 }
#define INSTR_TIME_SET_ZERO(t)
Definition: instr_time.h:172

References INSTR_TIME_SET_CURRENT, and INSTR_TIME_SET_ZERO.

Referenced by ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushBuffer(), FlushRelationBuffers(), GetLocalVictimBuffer(), IssuePendingWritebacks(), mdsyncfiletag(), register_dirty_segment(), and WaitReadBuffers().

◆ pgstat_report_analyze()

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

Definition at line 277 of file pgstat_relation.c.

280 {
281  PgStat_EntryRef *entry_ref;
282  PgStatShared_Relation *shtabentry;
283  PgStat_StatTabEntry *tabentry;
284  Oid dboid = (rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId);
285 
286  if (!pgstat_track_counts)
287  return;
288 
289  /*
290  * Unlike VACUUM, ANALYZE might be running inside a transaction that has
291  * already inserted and/or deleted rows in the target table. ANALYZE will
292  * have counted such rows as live or dead respectively. Because we will
293  * report our counts of such rows at transaction end, we should subtract
294  * off these counts from the update we're making now, else they'll be
295  * double-counted after commit. (This approach also ensures that the
296  * shared stats entry ends up with the right numbers if we abort instead
297  * of committing.)
298  *
299  * Waste no time on partitioned tables, though.
300  */
301  if (pgstat_should_count_relation(rel) &&
302  rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
303  {
305 
306  for (trans = rel->pgstat_info->trans; trans; trans = trans->upper)
307  {
308  livetuples -= trans->tuples_inserted - trans->tuples_deleted;
309  deadtuples -= trans->tuples_updated + trans->tuples_deleted;
310  }
311  /* count stuff inserted by already-aborted subxacts, too */
312  deadtuples -= rel->pgstat_info->counts.delta_dead_tuples;
313  /* Since ANALYZE's counts are estimates, we could have underflowed */
314  livetuples = Max(livetuples, 0);
315  deadtuples = Max(deadtuples, 0);
316  }
317 
318  /* block acquiring lock for the same reason as pgstat_report_autovac() */
320  RelationGetRelid(rel),
321  false);
322  /* can't get dropped while accessed */
323  Assert(entry_ref != NULL && entry_ref->shared_stats != NULL);
324 
325  shtabentry = (PgStatShared_Relation *) entry_ref->shared_stats;
326  tabentry = &shtabentry->stats;
327 
328  tabentry->live_tuples = livetuples;
329  tabentry->dead_tuples = deadtuples;
330 
331  /*
332  * If commanded, reset mod_since_analyze to zero. This forgets any
333  * changes that were committed while the ANALYZE was in progress, but we
334  * have no good way to estimate how many of those there were.
335  */
336  if (resetcounter)
337  tabentry->mod_since_analyze = 0;
338 
340  {
342  tabentry->autoanalyze_count++;
343  }
344  else
345  {
347  tabentry->analyze_count++;
348  }
349 
350  pgstat_unlock_entry(entry_ref);
351 
352  /* see pgstat_report_vacuum() */
353  pgstat_flush_io(false);
354 }
TimestampTz GetCurrentTimestamp(void)
Definition: timestamp.c:1654
#define Max(x, y)
Definition: c.h:998
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
#define AmAutoVacuumWorkerProcess()
Definition: miscadmin.h:375
bool pgstat_flush_io(bool nowait)
Definition: pgstat_io.c:173
PgStat_Counter mod_since_analyze
Definition: pgstat.h:415
PgStat_Counter analyze_count
Definition: pgstat.h:426
PgStat_Counter live_tuples
Definition: pgstat.h:413
TimestampTz last_analyze_time
Definition: pgstat.h:425
PgStat_Counter dead_tuples
Definition: pgstat.h:414
PgStat_Counter autoanalyze_count
Definition: pgstat.h:428
TimestampTz last_autoanalyze_time
Definition: pgstat.h:427
PgStat_Counter delta_dead_tuples
Definition: pgstat.h:175

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

Referenced by do_analyze_rel().

◆ pgstat_report_archiver()

void pgstat_report_archiver ( const char *  xlog,
bool  failed 
)

Definition at line 28 of file pgstat_archiver.c.

29 {
32 
34 
35  if (failed)
36  {
37  ++stats_shmem->stats.failed_count;
38  memcpy(&stats_shmem->stats.last_failed_wal, xlog,
39  sizeof(stats_shmem->stats.last_failed_wal));
40  stats_shmem->stats.last_failed_timestamp = now;
41  }
42  else
43  {
44  ++stats_shmem->stats.archived_count;
45  memcpy(&stats_shmem->stats.last_archived_wal, xlog,
46  sizeof(stats_shmem->stats.last_archived_wal));
47  stats_shmem->stats.last_archived_timestamp = now;
48  }
49 
51 }
Datum now(PG_FUNCTION_ARGS)
Definition: timestamp.c:1618
int64 TimestampTz
Definition: timestamp.h:39
static void pgstat_end_changecount_write(uint32 *cc)
static void pgstat_begin_changecount_write(uint32 *cc)
PgStat_ArchiverStats stats
TimestampTz last_failed_timestamp
Definition: pgstat.h:249
TimestampTz last_archived_timestamp
Definition: pgstat.h:245
char last_failed_wal[MAX_XFN_CHARS+1]
Definition: pgstat.h:247
PgStat_Counter failed_count
Definition: pgstat.h:246
PgStat_Counter archived_count
Definition: pgstat.h:242
char last_archived_wal[MAX_XFN_CHARS+1]
Definition: pgstat.h:243
PgStatShared_Archiver archiver

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

Referenced by pgarch_ArchiverCopyLoop().

◆ pgstat_report_autovac()

void pgstat_report_autovac ( Oid  dboid)

Definition at line 55 of file pgstat_database.c.

56 {
57  PgStat_EntryRef *entry_ref;
58  PgStatShared_Database *dbentry;
59 
60  /* can't get here in single user mode */
62 
63  /*
64  * End-of-vacuum is reported instantly. Report the start the same way for
65  * consistency. Vacuum doesn't run frequently and is a long-lasting
66  * operation so it doesn't matter if we get blocked here a little.
67  */
69  dboid, InvalidOid, false);
70 
71  dbentry = (PgStatShared_Database *) entry_ref->shared_stats;
73 
74  pgstat_unlock_entry(entry_ref);
75 }
bool IsUnderPostmaster
Definition: globals.c:117
PgStat_StatDBEntry stats
TimestampTz last_autovac_time
Definition: pgstat.h:334

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

Referenced by AutoVacWorkerMain().

◆ pgstat_report_bgwriter()

void pgstat_report_bgwriter ( void  )

Definition at line 30 of file pgstat_bgwriter.c.

31 {
33  static const PgStat_BgWriterStats all_zeroes;
34 
37 
38  /*
39  * This function can be called even if nothing at all has happened. In
40  * this case, avoid unnecessarily modifying the stats entry.
41  */
42  if (memcmp(&PendingBgWriterStats, &all_zeroes, sizeof(all_zeroes)) == 0)
43  return;
44 
46 
47 #define BGWRITER_ACC(fld) stats_shmem->stats.fld += PendingBgWriterStats.fld
48  BGWRITER_ACC(buf_written_clean);
49  BGWRITER_ACC(maxwritten_clean);
50  BGWRITER_ACC(buf_alloc);
51 #undef BGWRITER_ACC
52 
54 
55  /*
56  * Clear out the statistics buffer, so it can be re-used.
57  */
59 
60  /*
61  * Report IO statistics
62  */
63  pgstat_flush_io(false);
64 }
#define MemSet(start, val, len)
Definition: c.h:1020
#define BGWRITER_ACC(fld)
PgStat_BgWriterStats PendingBgWriterStats
PgStatShared_BgWriter bgwriter

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

Referenced by BackgroundWriterMain().

◆ pgstat_report_checkpointer()

void pgstat_report_checkpointer ( void  )

Definition at line 30 of file pgstat_checkpointer.c.

31 {
32  /* We assume this initializes to zeroes */
33  static const PgStat_CheckpointerStats all_zeroes;
35 
38 
39  /*
40  * This function can be called even if nothing at all has happened. In
41  * this case, avoid unnecessarily modifying the stats entry.
42  */
43  if (memcmp(&PendingCheckpointerStats, &all_zeroes,
44  sizeof(all_zeroes)) == 0)
45  return;
46 
48 
49 #define CHECKPOINTER_ACC(fld) stats_shmem->stats.fld += PendingCheckpointerStats.fld
50  CHECKPOINTER_ACC(num_timed);
51  CHECKPOINTER_ACC(num_requested);
52  CHECKPOINTER_ACC(restartpoints_timed);
53  CHECKPOINTER_ACC(restartpoints_requested);
54  CHECKPOINTER_ACC(restartpoints_performed);
55  CHECKPOINTER_ACC(write_time);
56  CHECKPOINTER_ACC(sync_time);
57  CHECKPOINTER_ACC(buffers_written);
58 #undef CHECKPOINTER_ACC
59 
61 
62  /*
63  * Clear out the statistics buffer, so it can be re-used.
64  */
66 
67  /*
68  * Report IO statistics
69  */
70  pgstat_flush_io(false);
71 }
PgStat_CheckpointerStats PendingCheckpointerStats
#define CHECKPOINTER_ACC(fld)
PgStatShared_Checkpointer checkpointer

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

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

◆ pgstat_report_checksum_failure()

void pgstat_report_checksum_failure ( void  )

Definition at line 166 of file pgstat_database.c.

167 {
169 }
void pgstat_report_checksum_failures_in_db(Oid dboid, int failurecount)

References MyDatabaseId, and pgstat_report_checksum_failures_in_db().

Referenced by PageIsVerifiedExtended().

◆ pgstat_report_checksum_failures_in_db()

void pgstat_report_checksum_failures_in_db ( Oid  dboid,
int  failurecount 
)

Definition at line 140 of file pgstat_database.c.

141 {
142  PgStat_EntryRef *entry_ref;
143  PgStatShared_Database *sharedent;
144 
145  if (!pgstat_track_counts)
146  return;
147 
148  /*
149  * Update the shared stats directly - checksum failures should never be
150  * common enough for that to be a problem.
151  */
152  entry_ref =
154 
155  sharedent = (PgStatShared_Database *) entry_ref->shared_stats;
156  sharedent->stats.checksum_failures += failurecount;
158 
159  pgstat_unlock_entry(entry_ref);
160 }
TimestampTz last_checksum_failure
Definition: pgstat.h:345
PgStat_Counter checksum_failures
Definition: pgstat.h:344

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

Referenced by pgstat_report_checksum_failure(), and sendFile().

◆ pgstat_report_connect()

void pgstat_report_connect ( Oid  dboid)

Definition at line 191 of file pgstat_database.c.

192 {
193  PgStat_StatDBEntry *dbentry;
194 
196  return;
197 
199 
201  dbentry->sessions++;
202 }
TimestampTz MyStartTimestamp
Definition: globals.c:47
static bool pgstat_should_report_connstat(void)
static PgStat_Counter pgLastSessionReportTime
PgStat_StatDBEntry * pgstat_prep_database_pending(Oid dboid)
PgStat_Counter sessions
Definition: pgstat.h:348

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

Referenced by PostgresMain().

◆ pgstat_report_deadlock()

void pgstat_report_deadlock ( void  )

Definition at line 125 of file pgstat_database.c.

126 {
127  PgStat_StatDBEntry *dbent;
128 
129  if (!pgstat_track_counts)
130  return;
131 
133  dbent->deadlocks++;
134 }
PgStat_Counter deadlocks
Definition: pgstat.h:343

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

Referenced by DeadLockReport().

◆ pgstat_report_recovery_conflict()

void pgstat_report_recovery_conflict ( int  reason)

Definition at line 81 of file pgstat_database.c.

82 {
83  PgStat_StatDBEntry *dbentry;
84 
87  return;
88 
90 
91  switch (reason)
92  {
94 
95  /*
96  * Since we drop the information about the database as soon as it
97  * replicates, there is no point in counting these conflicts.
98  */
99  break;
101  dbentry->conflict_tablespace++;
102  break;
104  dbentry->conflict_lock++;
105  break;
107  dbentry->conflict_snapshot++;
108  break;
110  dbentry->conflict_bufferpin++;
111  break;
113  dbentry->conflict_logicalslot++;
114  break;
116  dbentry->conflict_startup_deadlock++;
117  break;
118  }
119 }
@ PROCSIG_RECOVERY_CONFLICT_BUFFERPIN
Definition: procsignal.h:47
@ PROCSIG_RECOVERY_CONFLICT_LOCK
Definition: procsignal.h:44
@ PROCSIG_RECOVERY_CONFLICT_LOGICALSLOT
Definition: procsignal.h:46
@ PROCSIG_RECOVERY_CONFLICT_DATABASE
Definition: procsignal.h:42
@ PROCSIG_RECOVERY_CONFLICT_SNAPSHOT
Definition: procsignal.h:45
@ PROCSIG_RECOVERY_CONFLICT_TABLESPACE
Definition: procsignal.h:43
@ PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK
Definition: procsignal.h:48
PgStat_Counter conflict_startup_deadlock
Definition: pgstat.h:340
PgStat_Counter conflict_lock
Definition: pgstat.h:336
PgStat_Counter conflict_snapshot
Definition: pgstat.h:337
PgStat_Counter conflict_bufferpin
Definition: pgstat.h:339
PgStat_Counter conflict_logicalslot
Definition: pgstat.h:338
PgStat_Counter conflict_tablespace
Definition: pgstat.h:335

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

Referenced by ProcessRecoveryConflictInterrupt().

◆ pgstat_report_replslot()

void pgstat_report_replslot ( struct ReplicationSlot slot,
const PgStat_StatReplSlotEntry repSlotStat 
)

Definition at line 78 of file pgstat_replslot.c.

79 {
80  PgStat_EntryRef *entry_ref;
81  PgStatShared_ReplSlot *shstatent;
82  PgStat_StatReplSlotEntry *statent;
83 
85  ReplicationSlotIndex(slot), false);
86  shstatent = (PgStatShared_ReplSlot *) entry_ref->shared_stats;
87  statent = &shstatent->stats;
88 
89  /* Update the replication slot statistics */
90 #define REPLSLOT_ACC(fld) statent->fld += repSlotStat->fld
91  REPLSLOT_ACC(spill_txns);
92  REPLSLOT_ACC(spill_count);
93  REPLSLOT_ACC(spill_bytes);
94  REPLSLOT_ACC(stream_txns);
95  REPLSLOT_ACC(stream_count);
96  REPLSLOT_ACC(stream_bytes);
97  REPLSLOT_ACC(total_txns);
98  REPLSLOT_ACC(total_bytes);
99 #undef REPLSLOT_ACC
100 
101  pgstat_unlock_entry(entry_ref);
102 }
#define REPLSLOT_ACC(fld)

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

Referenced by UpdateDecodingStats().

◆ pgstat_report_stat()

long pgstat_report_stat ( bool  force)

Definition at line 579 of file pgstat.c.

580 {
581  static TimestampTz pending_since = 0;
582  static TimestampTz last_flush = 0;
583  bool partial_flush;
585  bool nowait;
586 
589 
590  /* "absorb" the forced flush even if there's nothing to flush */
592  {
593  force = true;
594  pgStatForceNextFlush = false;
595  }
596 
597  /* Don't expend a clock check if nothing to do */
599  !have_iostats &&
600  !have_slrustats &&
602  {
603  Assert(pending_since == 0);
604  return 0;
605  }
606 
607  /*
608  * There should never be stats to report once stats are shut down. Can't
609  * assert that before the checks above, as there is an unconditional
610  * pgstat_report_stat() call in pgstat_shutdown_hook() - which at least
611  * the process that ran pgstat_before_server_shutdown() will still call.
612  */
614 
615  if (force)
616  {
617  /*
618  * Stats reports are forced either when it's been too long since stats
619  * have been reported or in processes that force stats reporting to
620  * happen at specific points (including shutdown). In the former case
621  * the transaction stop time might be quite old, in the latter it
622  * would never get cleared.
623  */
625  }
626  else
627  {
629 
630  if (pending_since > 0 &&
632  {
633  /* don't keep pending updates longer than PGSTAT_MAX_INTERVAL */
634  force = true;
635  }
636  else if (last_flush > 0 &&
638  {
639  /* don't flush too frequently */
640  if (pending_since == 0)
641  pending_since = now;
642 
643  return PGSTAT_IDLE_INTERVAL;
644  }
645  }
646 
648 
649  /* don't wait for lock acquisition when !force */
650  nowait = !force;
651 
652  partial_flush = false;
653 
654  /* flush database / relation / function / ... stats */
655  partial_flush |= pgstat_flush_pending_entries(nowait);
656 
657  /* flush IO stats */
658  partial_flush |= pgstat_flush_io(nowait);
659 
660  /* flush wal stats */
661  partial_flush |= pgstat_flush_wal(nowait);
662 
663  /* flush SLRU stats */
664  partial_flush |= pgstat_slru_flush(nowait);
665 
666  last_flush = now;
667 
668  /*
669  * If some of the pending stats could not be flushed due to lock
670  * contention, let the caller know when to retry.
671  */
672  if (partial_flush)
673  {
674  /* force should have prevented us from getting here */
675  Assert(!force);
676 
677  /* remember since when stats have been pending */
678  if (pending_since == 0)
679  pending_since = now;
680 
681  return PGSTAT_IDLE_INTERVAL;
682  }
683 
684  pending_since = 0;
685 
686  return 0;
687 }
bool TimestampDifferenceExceeds(TimestampTz start_time, TimestampTz stop_time, int msec)
Definition: timestamp.c:1790
static bool dlist_is_empty(const dlist_head *head)
Definition: ilist.h:336
#define PGSTAT_MIN_INTERVAL
Definition: pgstat.c:117
static bool pgstat_flush_pending_entries(bool nowait)
Definition: pgstat.c:1180
static dlist_head pgStatPending
Definition: pgstat.c:218
#define PGSTAT_MAX_INTERVAL
Definition: pgstat.c:119
#define PGSTAT_IDLE_INTERVAL
Definition: pgstat.c:121
void pgstat_update_dbstats(TimestampTz ts)
bool have_slrustats
Definition: pgstat_slru.c:35
bool pgstat_slru_flush(bool nowait)
Definition: pgstat_slru.c:156
bool pgstat_have_pending_wal(void)
Definition: pgstat_wal.c:159
bool pgstat_flush_wal(bool nowait)
Definition: pgstat_wal.c:82
bool IsTransactionOrTransactionBlock(void)
Definition: xact.c:4933
TimestampTz GetCurrentTransactionStopTimestamp(void)
Definition: xact.c:888

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

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

◆ pgstat_report_subscription_error()

void pgstat_report_subscription_error ( Oid  subid,
bool  is_apply_error 
)

Definition at line 27 of file pgstat_subscription.c.

28 {
29  PgStat_EntryRef *entry_ref;
30  PgStat_BackendSubEntry *pending;
31 
33  InvalidOid, subid, NULL);
34  pending = entry_ref->pending;
35 
36  if (is_apply_error)
37  pending->apply_error_count++;
38  else
39  pending->sync_error_count++;
40 }
PgStat_EntryRef * pgstat_prep_pending_entry(PgStat_Kind kind, Oid dboid, Oid objoid, bool *created_entry)
Definition: pgstat.c:1105
PgStat_Counter apply_error_count
Definition: pgstat.h:136
PgStat_Counter sync_error_count
Definition: pgstat.h:137

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

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

◆ pgstat_report_vacuum()

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

Definition at line 211 of file pgstat_relation.c.

213 {
214  PgStat_EntryRef *entry_ref;
215  PgStatShared_Relation *shtabentry;
216  PgStat_StatTabEntry *tabentry;
217  Oid dboid = (shared ? InvalidOid : MyDatabaseId);
218  TimestampTz ts;
219 
220  if (!pgstat_track_counts)
221  return;
222 
223  /* Store the data in the table's hash table entry. */
224  ts = GetCurrentTimestamp();
225 
226  /* block acquiring lock for the same reason as pgstat_report_autovac() */
228  dboid, tableoid, false);
229 
230  shtabentry = (PgStatShared_Relation *) entry_ref->shared_stats;
231  tabentry = &shtabentry->stats;
232 
233  tabentry->live_tuples = livetuples;
234  tabentry->dead_tuples = deadtuples;
235 
236  /*
237  * It is quite possible that a non-aggressive VACUUM ended up skipping
238  * various pages, however, we'll zero the insert counter here regardless.
239  * It's currently used only to track when we need to perform an "insert"
240  * autovacuum, which are mainly intended to freeze newly inserted tuples.
241  * Zeroing this may just mean we'll not try to vacuum the table again
242  * until enough tuples have been inserted to trigger another insert
243  * autovacuum. An anti-wraparound autovacuum will catch any persistent
244  * stragglers.
245  */
246  tabentry->ins_since_vacuum = 0;
247 
249  {
250  tabentry->last_autovacuum_time = ts;
251  tabentry->autovacuum_count++;
252  }
253  else
254  {
255  tabentry->last_vacuum_time = ts;
256  tabentry->vacuum_count++;
257  }
258 
259  pgstat_unlock_entry(entry_ref);
260 
261  /*
262  * Flush IO statistics now. pgstat_report_stat() will flush IO stats,
263  * however this will not be called until after an entire autovacuum cycle
264  * is done -- which will likely vacuum many relations -- or until the
265  * VACUUM command has processed all tables and committed.
266  */
267  pgstat_flush_io(false);
268 }
PgStat_Counter vacuum_count
Definition: pgstat.h:422
PgStat_Counter ins_since_vacuum
Definition: pgstat.h:416
TimestampTz last_autovacuum_time
Definition: pgstat.h:423
PgStat_Counter autovacuum_count
Definition: pgstat.h:424
TimestampTz last_vacuum_time
Definition: pgstat.h:421

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

Referenced by heap_vacuum_rel().

◆ pgstat_report_wal()

void pgstat_report_wal ( bool  force)

Definition at line 48 of file pgstat_wal.c.

49 {
50  bool nowait;
51 
52  /* like in pgstat.c, don't wait for lock acquisition when !force */
53  nowait = !force;
54 
55  /* flush wal stats */
56  pgstat_flush_wal(nowait);
57 
58  /* flush IO stats */
59  pgstat_flush_io(nowait);
60 }

References pgstat_flush_io(), and pgstat_flush_wal().

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

◆ pgstat_reset()

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

Definition at line 734 of file pgstat.c.

735 {
736  const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
738 
739  /* not needed atm, and doesn't make sense with the current signature */
740  Assert(!pgstat_get_kind_info(kind)->fixed_amount);
741 
742  /* reset the "single counter" */
743  pgstat_reset_entry(kind, dboid, objoid, ts);
744 
745  if (!kind_info->accessed_across_databases)
747 }
void pgstat_reset_database_timestamp(Oid dboid, TimestampTz ts)
bool accessed_across_databases

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

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

◆ pgstat_reset_counters()

void pgstat_reset_counters ( void  )

Definition at line 715 of file pgstat.c.

716 {
718 
721  ts);
722 }
static bool match_db_entries(PgStatShared_HashEntry *entry, Datum match_data)
Definition: pgstat.c:703
void pgstat_reset_matching_entries(bool(*do_reset)(PgStatShared_HashEntry *, Datum), Datum match_data, TimestampTz ts)
Definition: pgstat_shmem.c:969
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252

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

Referenced by pg_stat_reset().

◆ pgstat_reset_of_kind()

void pgstat_reset_of_kind ( PgStat_Kind  kind)

Definition at line 756 of file pgstat.c.

757 {
758  const PgStat_KindInfo *kind_info = pgstat_get_kind_info(kind);
760 
761  if (kind_info->fixed_amount)
762  kind_info->reset_all_cb(ts);
763  else
765 }
void pgstat_reset_entries_of_kind(PgStat_Kind kind, TimestampTz ts)
void(* reset_all_cb)(TimestampTz ts)

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

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

◆ pgstat_reset_replslot()

void pgstat_reset_replslot ( const char *  name)

Definition at line 42 of file pgstat_replslot.c.

43 {
44  ReplicationSlot *slot;
45 
46  Assert(name != NULL);
47 
48  LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
49 
50  /* Check if the slot exits with the given name. */
51  slot = SearchNamedReplicationSlot(name, false);
52 
53  if (!slot)
54  ereport(ERROR,
55  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
56  errmsg("replication slot \"%s\" does not exist",
57  name)));
58 
59  /*
60  * Reset stats if it is a logical slot. Nothing to do for physical slots
61  * as we collect stats only for logical slots.
62  */
63  if (SlotIsLogical(slot))
65  ReplicationSlotIndex(slot));
66 
67  LWLockRelease(ReplicationSlotControlLock);
68 }
void pgstat_reset(PgStat_Kind kind, Oid dboid, Oid objoid)
Definition: pgstat.c:734
ReplicationSlot * SearchNamedReplicationSlot(const char *name, bool need_lock)
Definition: slot.c:464
#define SlotIsLogical(slot)
Definition: slot.h:210

References Assert, ereport, errcode(), errmsg(), ERROR, 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)

Definition at line 45 of file pgstat_slru.c.

46 {
48 
49  Assert(name != NULL);
50 
52 }
int pgstat_get_slru_index(const char *name)
Definition: pgstat_slru.c:132
static void pgstat_reset_slru_counter_internal(int index, TimestampTz ts)
Definition: pgstat_slru.c:238

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

Referenced by pg_stat_reset_slru().

◆ pgstat_restore_stats()

void pgstat_restore_stats ( void  )

Definition at line 407 of file pgstat.c.

408 {
410 }
static void pgstat_read_statsfile(void)
Definition: pgstat.c:1483

References pgstat_read_statsfile().

Referenced by StartupXLOG().

◆ pgstat_tracks_io_bktype()

bool pgstat_tracks_io_bktype ( BackendType  bktype)

Definition at line 319 of file pgstat_io.c.

320 {
321  /*
322  * List every type so that new backend types trigger a warning about
323  * needing to adjust this switch.
324  */
325  switch (bktype)
326  {
327  case B_INVALID:
328  case B_ARCHIVER:
329  case B_LOGGER:
330  case B_WAL_RECEIVER:
331  case B_WAL_WRITER:
332  case B_WAL_SUMMARIZER:
333  return false;
334 
335  case B_AUTOVAC_LAUNCHER:
336  case B_AUTOVAC_WORKER:
337  case B_BACKEND:
338  case B_BG_WORKER:
339  case B_BG_WRITER:
340  case B_CHECKPOINTER:
341  case B_SLOTSYNC_WORKER:
343  case B_STARTUP:
344  case B_WAL_SENDER:
345  return true;
346  }
347 
348  return false;
349 }
@ B_WAL_SUMMARIZER
Definition: miscadmin.h:360
@ B_WAL_WRITER
Definition: miscadmin.h:361
@ B_WAL_RECEIVER
Definition: miscadmin.h:359
@ B_CHECKPOINTER
Definition: miscadmin.h:357
@ B_WAL_SENDER
Definition: miscadmin.h:342
@ B_LOGGER
Definition: miscadmin.h:367
@ B_STARTUP
Definition: miscadmin.h:358
@ B_BG_WORKER
Definition: miscadmin.h:341
@ B_INVALID
Definition: miscadmin.h:335
@ B_STANDALONE_BACKEND
Definition: miscadmin.h:345
@ B_BG_WRITER
Definition: miscadmin.h:356
@ B_BACKEND
Definition: miscadmin.h:338
@ B_ARCHIVER
Definition: miscadmin.h:355
@ B_AUTOVAC_LAUNCHER
Definition: miscadmin.h:339
@ B_SLOTSYNC_WORKER
Definition: miscadmin.h:343
@ B_AUTOVAC_WORKER
Definition: miscadmin.h:340

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

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 
)

Definition at line 359 of file pgstat_io.c.

361 {
362  bool no_temp_rel;
363 
364  /*
365  * Some BackendTypes should never track IO statistics.
366  */
367  if (!pgstat_tracks_io_bktype(bktype))
368  return false;
369 
370  /*
371  * Currently, IO on temporary relations can only occur in the
372  * IOCONTEXT_NORMAL IOContext.
373  */
374  if (io_context != IOCONTEXT_NORMAL &&
375  io_object == IOOBJECT_TEMP_RELATION)
376  return false;
377 
378  /*
379  * In core Postgres, only regular backends and WAL Sender processes
380  * executing queries will use local buffers and operate on temporary
381  * relations. Parallel workers will not use local buffers (see
382  * InitLocalBuffers()); however, extensions leveraging background workers
383  * have no such limitation, so track IO on IOOBJECT_TEMP_RELATION for
384  * BackendType B_BG_WORKER.
385  */
386  no_temp_rel = bktype == B_AUTOVAC_LAUNCHER || bktype == B_BG_WRITER ||
387  bktype == B_CHECKPOINTER || bktype == B_AUTOVAC_WORKER ||
388  bktype == B_STANDALONE_BACKEND || bktype == B_STARTUP;
389 
390  if (no_temp_rel && io_context == IOCONTEXT_NORMAL &&
391  io_object == IOOBJECT_TEMP_RELATION)
392  return false;
393 
394  /*
395  * Some BackendTypes do not currently perform any IO in certain
396  * IOContexts, and, while it may not be inherently incorrect for them to
397  * do so, excluding those rows from the view makes the view easier to use.
398  */
399  if ((bktype == B_CHECKPOINTER || bktype == B_BG_WRITER) &&
400  (io_context == IOCONTEXT_BULKREAD ||
401  io_context == IOCONTEXT_BULKWRITE ||
402  io_context == IOCONTEXT_VACUUM))
403  return false;
404 
405  if (bktype == B_AUTOVAC_LAUNCHER && io_context == IOCONTEXT_VACUUM)
406  return false;
407 
408  if ((bktype == B_AUTOVAC_WORKER || bktype == B_AUTOVAC_LAUNCHER) &&
409  io_context == IOCONTEXT_BULKWRITE)
410  return false;
411 
412  return true;
413 }
bool pgstat_tracks_io_bktype(BackendType bktype)
Definition: pgstat_io.c:319

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

Referenced by pg_stat_get_io(), and pgstat_tracks_io_op().

◆ pgstat_tracks_io_op()

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

Definition at line 424 of file pgstat_io.c.

426 {
427  bool strategy_io_context;
428 
429  /* if (io_context, io_object) will never collect stats, we're done */
430  if (!pgstat_tracks_io_object(bktype, io_object, io_context))
431  return false;
432 
433  /*
434  * Some BackendTypes will not do certain IOOps.
435  */
436  if ((bktype == B_BG_WRITER || bktype == B_CHECKPOINTER) &&
437  (io_op == IOOP_READ || io_op == IOOP_EVICT || io_op == IOOP_HIT))
438  return false;
439 
440  if ((bktype == B_AUTOVAC_LAUNCHER || bktype == B_BG_WRITER ||
441  bktype == B_CHECKPOINTER) && io_op == IOOP_EXTEND)
442  return false;
443 
444  /*
445  * Temporary tables are not logged and thus do not require fsync'ing.
446  * Writeback is not requested for temporary tables.
447  */
448  if (io_object == IOOBJECT_TEMP_RELATION &&
449  (io_op == IOOP_FSYNC || io_op == IOOP_WRITEBACK))
450  return false;
451 
452  /*
453  * Some IOOps are not valid in certain IOContexts and some IOOps are only
454  * valid in certain contexts.
455  */
456  if (io_context == IOCONTEXT_BULKREAD && io_op == IOOP_EXTEND)
457  return false;
458 
459  strategy_io_context = io_context == IOCONTEXT_BULKREAD ||
460  io_context == IOCONTEXT_BULKWRITE || io_context == IOCONTEXT_VACUUM;
461 
462  /*
463  * IOOP_REUSE is only relevant when a BufferAccessStrategy is in use.
464  */
465  if (!strategy_io_context && io_op == IOOP_REUSE)
466  return false;
467 
468  /*
469  * IOOP_FSYNC IOOps done by a backend using a BufferAccessStrategy are
470  * counted in the IOCONTEXT_NORMAL IOContext. See comment in
471  * register_dirty_segment() for more details.
472  */
473  if (strategy_io_context && io_op == IOOP_FSYNC)
474  return false;
475 
476 
477  return true;
478 }
bool pgstat_tracks_io_object(BackendType bktype, IOObject io_object, IOContext io_context)
Definition: pgstat_io.c:359

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

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

◆ pgstat_twophase_postabort()

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

Definition at line 769 of file pgstat_relation.c.

771 {
772  TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
773  PgStat_TableStatus *pgstat_info;
774 
775  /* Find or create a tabstat entry for the rel */
776  pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared);
777 
778  /* Same math as in AtEOXact_PgStat, abort case */
779  if (rec->truncdropped)
780  {
784  }
785  pgstat_info->counts.tuples_inserted += rec->tuples_inserted;
786  pgstat_info->counts.tuples_updated += rec->tuples_updated;
787  pgstat_info->counts.tuples_deleted += rec->tuples_deleted;
788  pgstat_info->counts.delta_dead_tuples +=
789  rec->tuples_inserted + rec->tuples_updated;
790 }
PgStat_Counter deleted_pre_truncdrop
PgStat_Counter inserted_pre_truncdrop
PgStat_Counter updated_pre_truncdrop
PgStat_Counter tuples_deleted
PgStat_Counter tuples_inserted
PgStat_Counter tuples_updated

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

◆ pgstat_twophase_postcommit()

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

Definition at line 733 of file pgstat_relation.c.

735 {
736  TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
737  PgStat_TableStatus *pgstat_info;
738 
739  /* Find or create a tabstat entry for the rel */
740  pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared);
741 
742  /* Same math as in AtEOXact_PgStat, commit case */
743  pgstat_info->counts.tuples_inserted += rec->tuples_inserted;
744  pgstat_info->counts.tuples_updated += rec->tuples_updated;
745  pgstat_info->counts.tuples_deleted += rec->tuples_deleted;
746  pgstat_info->counts.truncdropped = rec->truncdropped;
747  if (rec->truncdropped)
748  {
749  /* forget live/dead stats seen by backend thus far */
750  pgstat_info->counts.delta_live_tuples = 0;
751  pgstat_info->counts.delta_dead_tuples = 0;
752  }
753  pgstat_info->counts.delta_live_tuples +=
754  rec->tuples_inserted - rec->tuples_deleted;
755  pgstat_info->counts.delta_dead_tuples +=
756  rec->tuples_updated + rec->tuples_deleted;
757  pgstat_info->counts.changed_tuples +=
758  rec->tuples_inserted + rec->tuples_updated +
759  rec->tuples_deleted;
760 }
PgStat_Counter delta_live_tuples
Definition: pgstat.h:174
PgStat_Counter changed_tuples
Definition: pgstat.h:176

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

◆ pgstat_unlink_relation()

void pgstat_unlink_relation ( Relation  rel)

Definition at line 153 of file pgstat_relation.c.

154 {
155  /* remove the link to stats info if any */
156  if (rel->pgstat_info == NULL)
157  return;
158 
159  /* link sanity check */
160  Assert(rel->pgstat_info->relation == rel);
161  rel->pgstat_info->relation = NULL;
162  rel->pgstat_info = NULL;
163 }

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

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

◆ pgstat_update_heap_dead_tuples()

void pgstat_update_heap_dead_tuples ( Relation  rel,
int  delta 
)

Definition at line 439 of file pgstat_relation.c.

440 {
442  {
443  PgStat_TableStatus *pgstat_info = rel->pgstat_info;
444 
445  pgstat_info->counts.delta_dead_tuples -= delta;
446  }
447 }

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

Referenced by heap_page_prune_opt().

◆ PostPrepare_PgStat()

void PostPrepare_PgStat ( void  )

Definition at line 209 of file pgstat_xact.c.

210 {
211  PgStat_SubXactStatus *xact_state;
212 
213  /*
214  * We don't bother to free any of the transactional state, since it's all
215  * in TopTransactionContext and will go away anyway.
216  */
217  xact_state = pgStatXactStack;
218  if (xact_state != NULL)
219  {
220  Assert(xact_state->nest_level == 1);
221  Assert(xact_state->prev == NULL);
222 
223  PostPrepare_PgStat_Relations(xact_state);
224  }
225  pgStatXactStack = NULL;
226 
227  /* Make sure any stats snapshot is thrown away */
229 }
void PostPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state)

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

Referenced by PrepareTransaction().

◆ StatsShmemInit()

void StatsShmemInit ( void  )

Definition at line 141 of file pgstat_shmem.c.

142 {
143  bool found;
144  Size sz;
145 
146  sz = StatsShmemSize();
148  ShmemInitStruct("Shared Memory Stats", sz, &found);
149 
150  if (!IsUnderPostmaster)
151  {
152  dsa_area *dsa;
153  dshash_table *dsh;
155  char *p = (char *) ctl;
156 
157  Assert(!found);
158 
159  /* the allocation of pgStatLocal.shmem itself */
160  p += MAXALIGN(sizeof(PgStat_ShmemControl));
161 
162  /*
163  * Create a small dsa allocation in plain shared memory. This is
164  * required because postmaster cannot use dsm segments. It also
165  * provides a small efficiency win.
166  */
167  ctl->raw_dsa_area = p;
169  dsa = dsa_create_in_place(ctl->raw_dsa_area,
172  dsa_pin(dsa);
173 
174  /*
175  * To ensure dshash is created in "plain" shared memory, temporarily
176  * limit size of dsa to the initial size of the dsa.
177  */
179 
180  /*
181  * With the limit in place, create the dshash table. XXX: It'd be nice
182  * if there were dshash_create_in_place().
183  */
184  dsh = dshash_create(dsa, &dsh_params, NULL);
185  ctl->hash_handle = dshash_get_hash_table_handle(dsh);
186 
187  /* lift limit set above */
188  dsa_set_size_limit(dsa, -1);
189 
190  /*
191  * Postmaster will never access these again, thus free the local
192  * dsa/dshash references.
193  */
194  dshash_detach(dsh);
195  dsa_detach(dsa);
196 
197  pg_atomic_init_u64(&ctl->gc_request_count, 1);
198 
199 
200  /* initialize fixed-numbered stats */
201  LWLockInitialize(&ctl->archiver.lock, LWTRANCHE_PGSTATS_DATA);
202  LWLockInitialize(&ctl->bgwriter.lock, LWTRANCHE_PGSTATS_DATA);
203  LWLockInitialize(&ctl->checkpointer.lock, LWTRANCHE_PGSTATS_DATA);
206 
207  for (int i = 0; i < BACKEND_NUM_TYPES; i++)
208  LWLockInitialize(&ctl->io.locks[i],
210  }
211  else
212  {
213  Assert(found);
214  }
215 }
static void pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
Definition: atomics.h:448
#define MAXALIGN(LEN)
Definition: c.h:811
size_t Size
Definition: c.h:605
void dsa_set_size_limit(dsa_area *area, size_t limit)
Definition: dsa.c:1018
void dsa_detach(dsa_area *area)
Definition: dsa.c:1952
void dsa_pin(dsa_area *area)
Definition: dsa.c:975
#define dsa_create_in_place(place, size, tranch_id, segment)
Definition: dsa.h:122
void dshash_detach(dshash_table *hash_table)
Definition: dshash.c:307
dshash_table_handle dshash_get_hash_table_handle(dshash_table *hash_table)
Definition: dshash.c:367
dshash_table * dshash_create(dsa_area *area, const dshash_parameters *params, void *arg)
Definition: dshash.c:206
void LWLockInitialize(LWLock *lock, int tranche_id)
Definition: lwlock.c:709
@ LWTRANCHE_PGSTATS_DSA
Definition: lwlock.h:203
@ LWTRANCHE_PGSTATS_DATA
Definition: lwlock.h:205
#define BACKEND_NUM_TYPES
Definition: miscadmin.h:370
static Size pgstat_dsa_init_size(void)
Definition: pgstat_shmem.c:106
Size StatsShmemSize(void)
Definition: pgstat_shmem.c:127
static const dshash_parameters dsh_params
Definition: pgstat_shmem.c:62
tree ctl
Definition: radixtree.h:1853
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:387
Definition: dsa.c:348

References Assert, BACKEND_NUM_TYPES, ctl, dsa_create_in_place, dsa_detach(), dsa_pin(), dsa_set_size_limit(), dsh_params, dshash_create(), dshash_detach(), dshash_get_hash_table_handle(), i, IsUnderPostmaster, LWLockInitialize(), LWTRANCHE_PGSTATS_DATA, LWTRANCHE_PGSTATS_DSA, MAXALIGN, pg_atomic_init_u64(), pgstat_dsa_init_size(), pgStatLocal, PgStat_LocalState::shmem, ShmemInitStruct(), and StatsShmemSize().

Referenced by CreateOrAttachShmemStructs().

◆ StatsShmemSize()

Size StatsShmemSize ( void  )

Definition at line 127 of file pgstat_shmem.c.

128 {
129  Size sz;
130 
131  sz = MAXALIGN(sizeof(PgStat_ShmemControl));
132  sz = add_size(sz, pgstat_dsa_init_size());
133 
134  return sz;
135 }
Size add_size(Size s1, Size s2)
Definition: shmem.c:493

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

Referenced by CalculateShmemSize(), and StatsShmemInit().

Variable Documentation

◆ PendingBgWriterStats

PGDLLIMPORT PgStat_BgWriterStats PendingBgWriterStats
extern

Definition at line 23 of file pgstat_bgwriter.c.

Referenced by BgBufferSync(), and pgstat_report_bgwriter().

◆ PendingCheckpointerStats

◆ PendingWalStats

◆ pgstat_fetch_consistency

◆ pgstat_track_counts

◆ 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().