| /* ---------- |
| * pgstat.h |
| * |
| * Definitions for the PostgreSQL statistics collector daemon. |
| * |
| * Copyright (c) 2001-2009, PostgreSQL Global Development Group |
| * |
| * $PostgreSQL: pgsql/src/include/pgstat.h,v 1.50.2.1 2007/07/08 22:23:25 tgl Exp $ |
| * ---------- |
| */ |
| #ifndef PGSTAT_H |
| #define PGSTAT_H |
| |
| #include "libpq/pqcomm.h" |
| #include "portability/instr_time.h" |
| #include "utils/hsearch.h" |
| #include "utils/rel.h" |
| #include "utils/relcache.h" |
| #include "utils/timestamp.h" |
| |
| |
| /* Values for track_functions GUC variable --- order is significant! */ |
| typedef enum TrackFunctionsLevel |
| { |
| TRACK_FUNC_OFF, |
| TRACK_FUNC_PL, |
| TRACK_FUNC_ALL |
| } TrackFunctionsLevel; |
| |
| /* ---------- |
| * The types of backend -> collector messages |
| * ---------- |
| */ |
| typedef enum StatMsgType |
| { |
| PGSTAT_MTYPE_DUMMY, |
| PGSTAT_MTYPE_INQUIRY, |
| PGSTAT_MTYPE_TABSTAT, |
| PGSTAT_MTYPE_TABPURGE, |
| PGSTAT_MTYPE_DROPDB, |
| PGSTAT_MTYPE_RESETCOUNTER, |
| PGSTAT_MTYPE_AUTOVAC_START, |
| PGSTAT_MTYPE_VACUUM, |
| PGSTAT_MTYPE_ANALYZE, |
| PGSTAT_MTYPE_QUEUESTAT, /* GPDB */ |
| PGSTAT_MTYPE_BGWRITER, |
| PGSTAT_MTYPE_FUNCSTAT, |
| PGSTAT_MTYPE_FUNCPURGE |
| } StatMsgType; |
| |
| /* ---------- |
| * The data type used for counters. |
| * ---------- |
| */ |
| typedef int64 PgStat_Counter; |
| |
| /* ---------- |
| * PgStat_TableCounts The actual per-table counts kept by a backend |
| * |
| * This struct should contain only actual event counters, because we memcmp |
| * it against zeroes to detect whether there are any counts to transmit. |
| * It is a component of PgStat_TableStatus (within-backend state) and |
| * PgStat_TableEntry (the transmitted message format). |
| * |
| * Note: for a table, tuples_returned is the number of tuples successfully |
| * fetched by heap_getnext, while tuples_fetched is the number of tuples |
| * successfully fetched by heap_fetch under the control of bitmap indexscans. |
| * For an index, tuples_returned is the number of index entries returned by |
| * the index AM, while tuples_fetched is the number of tuples successfully |
| * fetched by heap_fetch under the control of simple indexscans for this index. |
| * |
| * tuples_inserted/updated/deleted/hot_updated count attempted actions, |
| * regardless of whether the transaction committed. new_live_tuples and |
| * new_dead_tuples are properly adjusted depending on commit or abort. |
| * Note that new_live_tuples and new_dead_tuples can be negative! |
| * ---------- |
| */ |
| typedef struct PgStat_TableCounts |
| { |
| PgStat_Counter t_numscans; |
| |
| PgStat_Counter t_tuples_returned; |
| PgStat_Counter t_tuples_fetched; |
| |
| PgStat_Counter t_tuples_inserted; |
| PgStat_Counter t_tuples_updated; |
| PgStat_Counter t_tuples_deleted; |
| PgStat_Counter t_tuples_hot_updated; |
| |
| PgStat_Counter t_new_live_tuples; |
| PgStat_Counter t_new_dead_tuples; |
| |
| PgStat_Counter t_blocks_fetched; |
| PgStat_Counter t_blocks_hit; |
| } PgStat_TableCounts; |
| |
| |
| /* ------------------------------------------------------------ |
| * Structures kept in backend local memory while accumulating counts |
| * ------------------------------------------------------------ |
| */ |
| |
| |
| /* ---------- |
| * PgStat_TableStatus Per-table status within a backend |
| * |
| * Most of the event counters are nontransactional, ie, we count events |
| * in committed and aborted transactions alike. For these, we just count |
| * directly in the PgStat_TableStatus. However, new_live_tuples and |
| * new_dead_tuples must be derived from tuple insertion and deletion counts |
| * with awareness of whether the transaction or subtransaction committed or |
| * aborted. Hence, we also keep a stack of per-(sub)transaction status |
| * records for every table modified in the current transaction. At commit |
| * or abort, we propagate tuples_inserted and tuples_deleted up to the |
| * parent subtransaction level, or out to the parent PgStat_TableStatus, |
| * as appropriate. |
| * ---------- |
| */ |
| typedef struct PgStat_TableStatus |
| { |
| Oid t_id; /* table's OID */ |
| bool t_shared; /* is it a shared catalog? */ |
| struct PgStat_TableXactStatus *trans; /* lowest subxact's counts */ |
| PgStat_TableCounts t_counts; /* event counts to be sent */ |
| } PgStat_TableStatus; |
| |
| /* ---------- |
| * PgStat_TableXactStatus Per-table, per-subtransaction status |
| * ---------- |
| */ |
| typedef struct PgStat_TableXactStatus |
| { |
| PgStat_Counter tuples_inserted; /* tuples inserted in (sub)xact */ |
| PgStat_Counter tuples_deleted; /* tuples deleted in (sub)xact */ |
| int nest_level; /* subtransaction nest level */ |
| /* links to other structs for same relation: */ |
| struct PgStat_TableXactStatus *upper; /* next higher subxact if any */ |
| PgStat_TableStatus *parent; /* per-table status */ |
| /* structs of same subxact level are linked here: */ |
| struct PgStat_TableXactStatus *next; /* next of same subxact */ |
| } PgStat_TableXactStatus; |
| |
| |
| /* ------------------------------------------------------------ |
| * Message formats follow |
| * ------------------------------------------------------------ |
| */ |
| |
| |
| /* ---------- |
| * PgStat_MsgHdr The common message header |
| * ---------- |
| */ |
| typedef struct PgStat_MsgHdr |
| { |
| StatMsgType m_type; |
| int m_size; |
| } PgStat_MsgHdr; |
| |
| /* ---------- |
| * Space available in a message. This will keep the UDP packets below 1K, |
| * which should fit unfragmented into the MTU of the lo interface on most |
| * platforms. Does anybody care for platforms where it doesn't? |
| * ---------- |
| */ |
| #define PGSTAT_MSG_PAYLOAD (1000 - sizeof(PgStat_MsgHdr)) |
| |
| |
| /* ---------- |
| * PgStat_MsgDummy A dummy message, ignored by the collector |
| * ---------- |
| */ |
| typedef struct PgStat_MsgDummy |
| { |
| PgStat_MsgHdr m_hdr; |
| } PgStat_MsgDummy; |
| |
| |
| /* ---------- |
| * PgStat_MsgInquiry Sent by a backend to ask the collector |
| * to write the stats file. |
| * ---------- |
| */ |
| |
| typedef struct PgStat_MsgInquiry |
| { |
| PgStat_MsgHdr m_hdr; |
| TimestampTz inquiry_time; /* minimum acceptable file timestamp */ |
| } PgStat_MsgInquiry; |
| |
| |
| /* ---------- |
| * PgStat_TableEntry Per-table info in a MsgTabstat |
| * ---------- |
| */ |
| typedef struct PgStat_TableEntry |
| { |
| Oid t_id; |
| PgStat_TableCounts t_counts; |
| } PgStat_TableEntry; |
| |
| /* ---------- |
| * PgStat_MsgTabstat Sent by the backend to report table |
| * and buffer access statistics. |
| * ---------- |
| */ |
| #define PGSTAT_NUM_TABENTRIES \ |
| ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - 3 * sizeof(int)) \ |
| / sizeof(PgStat_TableEntry)) |
| |
| typedef struct PgStat_MsgTabstat |
| { |
| PgStat_MsgHdr m_hdr; |
| Oid m_databaseid; |
| int m_nentries; |
| int m_xact_commit; |
| int m_xact_rollback; |
| PgStat_TableEntry m_entry[PGSTAT_NUM_TABENTRIES]; |
| } PgStat_MsgTabstat; |
| |
| |
| /* ---------- |
| * PgStat_MsgTabpurge Sent by the backend to tell the collector |
| * about dead tables. |
| * ---------- |
| */ |
| #define PGSTAT_NUM_TABPURGE \ |
| ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \ |
| / sizeof(Oid)) |
| |
| typedef struct PgStat_MsgTabpurge |
| { |
| PgStat_MsgHdr m_hdr; |
| Oid m_databaseid; |
| int m_nentries; |
| Oid m_tableid[PGSTAT_NUM_TABPURGE]; |
| } PgStat_MsgTabpurge; |
| |
| |
| /* ---------- |
| * PgStat_MsgDropdb Sent by the backend to tell the collector |
| * about a dropped database |
| * ---------- |
| */ |
| typedef struct PgStat_MsgDropdb |
| { |
| PgStat_MsgHdr m_hdr; |
| Oid m_databaseid; |
| } PgStat_MsgDropdb; |
| |
| |
| /* ---------- |
| * PgStat_MsgResetcounter Sent by the backend to tell the collector |
| * to reset counters |
| * ---------- |
| */ |
| typedef struct PgStat_MsgResetcounter |
| { |
| PgStat_MsgHdr m_hdr; |
| Oid m_databaseid; |
| } PgStat_MsgResetcounter; |
| |
| |
| /* ---------- |
| * PgStat_MsgAutovacStart Sent by the autovacuum daemon to signal |
| * that a database is going to be processed |
| * ---------- |
| */ |
| typedef struct PgStat_MsgAutovacStart |
| { |
| PgStat_MsgHdr m_hdr; |
| Oid m_databaseid; |
| TimestampTz m_start_time; |
| } PgStat_MsgAutovacStart; |
| |
| |
| /* ---------- |
| * PgStat_MsgVacuum Sent by the backend or autovacuum daemon |
| * after VACUUM or VACUUM ANALYZE |
| * ---------- |
| */ |
| typedef struct PgStat_MsgVacuum |
| { |
| PgStat_MsgHdr m_hdr; |
| Oid m_databaseid; |
| Oid m_tableoid; |
| bool m_analyze; |
| bool m_autovacuum; |
| bool m_scanned_all; |
| TimestampTz m_vacuumtime; |
| PgStat_Counter m_tuples; |
| } PgStat_MsgVacuum; |
| |
| |
| /* ---------- |
| * PgStat_MsgAnalyze Sent by the backend or autovacuum daemon |
| * after ANALYZE |
| * ---------- |
| */ |
| typedef struct PgStat_MsgAnalyze |
| { |
| PgStat_MsgHdr m_hdr; |
| Oid m_databaseid; |
| Oid m_tableoid; |
| bool m_autovacuum; |
| TimestampTz m_analyzetime; |
| PgStat_Counter m_live_tuples; |
| PgStat_Counter m_dead_tuples; |
| } PgStat_MsgAnalyze; |
| |
| |
| /* ---------- |
| |
| * PgStat_MsgQueuestat Sent by the backend to report resource queue |
| * activity statistics. |
| * ---------- GPDB |
| */ |
| typedef struct PgStat_MsgQueuestat |
| { |
| PgStat_MsgHdr m_hdr; |
| Oid m_queueid; |
| PgStat_Counter m_queries_exec; |
| PgStat_Counter m_queries_wait; |
| PgStat_Counter m_elapsed_exec; |
| PgStat_Counter m_elapsed_wait; |
| } PgStat_MsgQueuestat; |
| |
| |
| /* ---------- |
| * PgStat_MsgBgWriter Sent by the bgwriter to update statistics. |
| * ---------- |
| */ |
| typedef struct PgStat_MsgBgWriter |
| { |
| PgStat_MsgHdr m_hdr; |
| |
| PgStat_Counter m_timed_checkpoints; |
| PgStat_Counter m_requested_checkpoints; |
| PgStat_Counter m_buf_written_checkpoints; |
| PgStat_Counter m_buf_written_clean; |
| PgStat_Counter m_maxwritten_clean; |
| PgStat_Counter m_buf_written_backend; |
| PgStat_Counter m_buf_alloc; |
| } PgStat_MsgBgWriter; |
| |
| |
| /* ---------- |
| * PgStat_FunctionCounts The actual per-function counts kept by a backend |
| * |
| * This struct should contain only actual event counters, because we memcmp |
| * it against zeroes to detect whether there are any counts to transmit. |
| * |
| * Note that the time counters are in instr_time format here. We convert to |
| * microseconds in PgStat_Counter format when transmitting to the collector. |
| * ---------- |
| */ |
| typedef struct PgStat_FunctionCounts |
| { |
| PgStat_Counter f_numcalls; |
| instr_time f_time; |
| instr_time f_time_self; |
| } PgStat_FunctionCounts; |
| |
| /* ---------- |
| * PgStat_BackendFunctionEntry Entry in backend's per-function hash table |
| * ---------- |
| */ |
| typedef struct PgStat_BackendFunctionEntry |
| { |
| Oid f_id; |
| PgStat_FunctionCounts f_counts; |
| } PgStat_BackendFunctionEntry; |
| |
| /* ---------- |
| * PgStat_FunctionEntry Per-function info in a MsgFuncstat |
| * ---------- |
| */ |
| typedef struct PgStat_FunctionEntry |
| { |
| Oid f_id; |
| PgStat_Counter f_numcalls; |
| PgStat_Counter f_time; /* times in microseconds */ |
| PgStat_Counter f_time_self; |
| } PgStat_FunctionEntry; |
| |
| /* ---------- |
| * PgStat_MsgFuncstat Sent by the backend to report function |
| * usage statistics. |
| * ---------- |
| */ |
| #define PGSTAT_NUM_FUNCENTRIES \ |
| ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \ |
| / sizeof(PgStat_FunctionEntry)) |
| |
| typedef struct PgStat_MsgFuncstat |
| { |
| PgStat_MsgHdr m_hdr; |
| Oid m_databaseid; |
| int m_nentries; |
| PgStat_FunctionEntry m_entry[PGSTAT_NUM_FUNCENTRIES]; |
| } PgStat_MsgFuncstat; |
| |
| /* ---------- |
| * PgStat_MsgFuncpurge Sent by the backend to tell the collector |
| * about dead functions. |
| * ---------- |
| */ |
| #define PGSTAT_NUM_FUNCPURGE \ |
| ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \ |
| / sizeof(Oid)) |
| |
| typedef struct PgStat_MsgFuncpurge |
| { |
| PgStat_MsgHdr m_hdr; |
| Oid m_databaseid; |
| int m_nentries; |
| Oid m_functionid[PGSTAT_NUM_FUNCPURGE]; |
| } PgStat_MsgFuncpurge; |
| |
| |
| /* ---------- |
| * PgStat_Msg Union over all possible messages. |
| * ---------- |
| */ |
| typedef union PgStat_Msg |
| { |
| PgStat_MsgHdr msg_hdr; |
| PgStat_MsgDummy msg_dummy; |
| PgStat_MsgInquiry msg_inquiry; |
| PgStat_MsgTabstat msg_tabstat; |
| PgStat_MsgTabpurge msg_tabpurge; |
| PgStat_MsgDropdb msg_dropdb; |
| PgStat_MsgResetcounter msg_resetcounter; |
| PgStat_MsgAutovacStart msg_autovacuum; |
| PgStat_MsgVacuum msg_vacuum; |
| PgStat_MsgAnalyze msg_analyze; |
| PgStat_MsgQueuestat msg_queuestat; /* GPDB */ |
| PgStat_MsgBgWriter msg_bgwriter; |
| PgStat_MsgFuncstat msg_funcstat; |
| PgStat_MsgFuncpurge msg_funcpurge; |
| } PgStat_Msg; |
| |
| |
| /* ------------------------------------------------------------ |
| * Statistic collector data structures follow |
| * |
| * PGSTAT_FILE_FORMAT_ID should be changed whenever any of these |
| * data structures change. |
| * ------------------------------------------------------------ |
| */ |
| |
| #define PGSTAT_FILE_FORMAT_ID 0x01A5BC98 |
| |
| /* ---------- |
| * PgStat_StatDBEntry The collector's data per database |
| * ---------- |
| */ |
| typedef struct PgStat_StatDBEntry |
| { |
| Oid databaseid; |
| PgStat_Counter n_xact_commit; |
| PgStat_Counter n_xact_rollback; |
| PgStat_Counter n_blocks_fetched; |
| PgStat_Counter n_blocks_hit; |
| PgStat_Counter n_tuples_returned; |
| PgStat_Counter n_tuples_fetched; |
| PgStat_Counter n_tuples_inserted; |
| PgStat_Counter n_tuples_updated; |
| PgStat_Counter n_tuples_deleted; |
| TimestampTz last_autovac_time; |
| |
| /* |
| * tables and functions must be last in the struct, because we don't write |
| * the pointers out to the stats file. |
| */ |
| HTAB *tables; |
| HTAB *functions; |
| } PgStat_StatDBEntry; |
| |
| |
| /* ---------- |
| * PgStat_StatTabEntry The collector's data per table (or index) |
| * ---------- |
| */ |
| typedef struct PgStat_StatTabEntry |
| { |
| Oid tableid; |
| |
| PgStat_Counter numscans; |
| |
| PgStat_Counter tuples_returned; |
| PgStat_Counter tuples_fetched; |
| |
| PgStat_Counter tuples_inserted; |
| PgStat_Counter tuples_updated; |
| PgStat_Counter tuples_deleted; |
| PgStat_Counter tuples_hot_updated; |
| |
| PgStat_Counter n_live_tuples; |
| PgStat_Counter n_dead_tuples; |
| PgStat_Counter last_anl_tuples; |
| |
| PgStat_Counter blocks_fetched; |
| PgStat_Counter blocks_hit; |
| |
| TimestampTz vacuum_timestamp; /* user initiated vacuum */ |
| TimestampTz autovac_vacuum_timestamp; /* autovacuum initiated */ |
| TimestampTz analyze_timestamp; /* user initiated */ |
| TimestampTz autovac_analyze_timestamp; /* autovacuum initiated */ |
| } PgStat_StatTabEntry; |
| |
| |
| /* ---------- |
| * PgStat_StatQueueEntry The collector's data per resource queue |
| * ---------- |
| * --- cdb extension --- |
| */ |
| typedef struct PgStat_StatQueueEntry |
| { |
| Oid queueid; |
| PgStat_Counter n_queries_exec; |
| PgStat_Counter n_queries_wait; |
| PgStat_Counter elapsed_exec; |
| PgStat_Counter elapsed_wait; |
| } PgStat_StatQueueEntry; |
| |
| /* ---------- |
| * PgStat_StatFuncEntry The collector's data per function |
| * ---------- |
| */ |
| typedef struct PgStat_StatFuncEntry |
| { |
| Oid functionid; |
| |
| PgStat_Counter f_numcalls; |
| |
| PgStat_Counter f_time; /* times in microseconds */ |
| PgStat_Counter f_time_self; |
| } PgStat_StatFuncEntry; |
| |
| |
| |
| /* ---------- |
| * PgStat_StatPortalEntry |
| * |
| * Each backend maintains a hash that contains a PgStat_StatPortalEntry for |
| * each portal. This is so we can easily track elapsed times for execute and |
| * wait, as well as counts for each of these. |
| * |
| * In order to (hopefully) not cause a performance degradation when queue |
| * statistics are enabled, we only store and caclulate elapsed time to the |
| * nearest second (via the time() call). This may mean that large numbers of |
| * sub-second queries get ignored due to roundoff. |
| * |
| * Note that the collector never sees these structs, the PgStat_StatQueueEntry |
| * is what is sent at report time. |
| * ---------- |
| */ |
| typedef struct PgStat_StatPortalEntry |
| { |
| uint32 portalid; |
| time_t t_exec_start; |
| time_t t_exec_end; |
| time_t t_wait_start; |
| time_t t_wait_end; |
| PgStat_StatQueueEntry queueentry; |
| } PgStat_StatPortalEntry; |
| |
| |
| /* |
| * Global statistics kept in the stats collector |
| */ |
| typedef struct PgStat_GlobalStats |
| { |
| TimestampTz stats_timestamp; /* time of stats file update */ |
| PgStat_Counter timed_checkpoints; |
| PgStat_Counter requested_checkpoints; |
| PgStat_Counter buf_written_checkpoints; |
| PgStat_Counter buf_written_clean; |
| PgStat_Counter maxwritten_clean; |
| PgStat_Counter buf_written_backend; |
| PgStat_Counter buf_alloc; |
| } PgStat_GlobalStats; |
| |
| |
| /* ---------- |
| * Shared-memory data structures |
| * ---------- |
| */ |
| |
| /* Max length of st_activity string ... perhaps replace with a GUC var? */ |
| #define PGBE_ACTIVITY_SIZE 1024 |
| |
| /* ---------- |
| * PgBackendStatus |
| * |
| * Each live backend maintains a PgBackendStatus struct in shared memory |
| * showing its current activity. (The structs are allocated according to |
| * BackendId, but that is not critical.) Note that the collector process |
| * has no involvement in, or even access to, these structs. |
| * ---------- |
| */ |
| typedef struct PgBackendStatus |
| { |
| /* |
| * To avoid locking overhead, we use the following protocol: a backend |
| * increments st_changecount before modifying its entry, and again after |
| * finishing a modification. A would-be reader should note the value of |
| * st_changecount, copy the entry into private memory, then check |
| * st_changecount again. If the value hasn't changed, and if it's even, |
| * the copy is valid; otherwise start over. This makes updates cheap |
| * while reads are potentially expensive, but that's the tradeoff we want. |
| */ |
| int st_changecount; |
| |
| /* The entry is valid iff st_procpid > 0, unused if st_procpid == 0 */ |
| int st_procpid; |
| |
| /* Times when current backend, transaction, and activity started */ |
| TimestampTz st_proc_start_timestamp; |
| TimestampTz st_xact_start_timestamp; |
| TimestampTz st_activity_start_timestamp; |
| |
| /* Database OID, owning user's OID, connection client address */ |
| Oid st_databaseid; |
| Oid st_userid; |
| int st_session_id; /* GPDB only */ |
| SockAddr st_clientaddr; |
| |
| /* Is backend currently waiting on an lmgr lock? */ |
| bool st_waiting; |
| |
| /* application name; MUST be null-terminated */ |
| char *st_appname; |
| |
| /* current command string; MUST be null-terminated */ |
| char *st_activity; |
| |
| /* Is backend currently waiting on resources? */ |
| bool st_waiting_resource; |
| } PgBackendStatus; |
| |
| /* |
| * Working state needed to accumulate per-function-call timing statistics. |
| */ |
| typedef struct PgStat_FunctionCallUsage |
| { |
| /* Link to function's hashtable entry (must still be there at exit!) */ |
| /* NULL means we are not tracking the current function call */ |
| PgStat_FunctionCounts *fs; |
| /* Total time previously charged to function, as of function start */ |
| instr_time save_f_time; |
| /* Backend-wide total time as of function start */ |
| instr_time save_total; |
| /* system clock as of function start */ |
| instr_time f_start; |
| } PgStat_FunctionCallUsage; |
| |
| |
| /* ---------- |
| * GUC parameters |
| * ---------- |
| */ |
| extern bool pgstat_collect_startcollector; // NOT USED |
| |
| extern bool pgstat_track_counts; |
| extern bool pgstat_track_counts; // NOT USED |
| extern bool pgstat_track_activities; // NOT USED |
| |
| extern bool pgstat_collect_queuelevel; |
| |
| extern int pgstat_track_functions; |
| //extern PGDLLIMPORT int pgstat_track_activity_query_size; |
| extern char *pgstat_stat_tmpname; |
| extern char *pgstat_stat_filename; |
| |
| /* |
| * BgWriter statistics counters are updated directly by bgwriter and bufmgr |
| */ |
| extern PgStat_MsgBgWriter BgWriterStats; |
| |
| /* ---------- |
| * Functions called from postmaster |
| * ---------- |
| */ |
| extern Size BackendStatusShmemSize(void); |
| extern void CreateSharedBackendStatus(void); |
| |
| extern void pgstat_init(void); |
| extern int pgstat_start(void); |
| extern void pgstat_reset_all(void); |
| extern void allow_immediate_pgstat_restart(void); |
| |
| #ifdef EXEC_BACKEND |
| extern void PgstatCollectorMain(int argc, char *argv[]); |
| #endif |
| |
| |
| /* ---------- |
| * Functions called from backends |
| * ---------- |
| */ |
| extern void pgstat_ping(void); |
| |
| extern void pgstat_report_stat(bool force); |
| extern void pgstat_vacuum_stat(void); |
| extern void pgstat_report_queuestat(void); /* GPDB */ |
| extern void pgstat_drop_database(Oid databaseid); |
| |
| extern void pgstat_clear_snapshot(void); |
| extern void pgstat_reset_counters(void); |
| |
| extern void pgstat_report_autovac(Oid dboid); |
| extern void pgstat_report_vacuum(Oid tableoid, bool shared, bool scanned_all, |
| bool analyze, PgStat_Counter tuples); |
| extern void pgstat_report_analyze(Relation rel, |
| PgStat_Counter livetuples, |
| PgStat_Counter deadtuples); |
| |
| extern void pgstat_initialize(void); |
| extern void pgstat_bestart(void); |
| |
| extern void pgstat_report_activity(const char *cmd_str); |
| extern void pgstat_report_appname(const char *appname); |
| extern void pgstat_report_xact_timestamp(TimestampTz tstamp); |
| extern void pgstat_report_waiting(bool waiting); |
| extern void pgstat_report_waiting_resource(bool waiting); |
| extern const char *pgstat_get_backend_current_activity(int pid, bool checkUser); |
| |
| extern void pgstat_initstats(Relation rel); |
| |
| extern void pgstat_init_localportalhash(void); |
| extern PgStat_StatPortalEntry *pgstat_getportalentry(uint32 portalid, |
| Oid queueid); |
| |
| /* nontransactional event counts are simple enough to inline */ |
| |
| #define pgstat_count_heap_scan(rel) \ |
| do { \ |
| if (pgstat_track_counts && (rel)->pgstat_info != NULL) \ |
| (rel)->pgstat_info->t_counts.t_numscans++; \ |
| } while (0) |
| /* kluge for bitmap scans: */ |
| #define pgstat_discount_heap_scan(rel) \ |
| do { \ |
| if (pgstat_track_counts && (rel)->pgstat_info != NULL) \ |
| (rel)->pgstat_info->t_counts.t_numscans--; \ |
| } while (0) |
| #define pgstat_count_heap_getnext(rel) \ |
| do { \ |
| if (pgstat_track_counts && (rel)->pgstat_info != NULL) \ |
| (rel)->pgstat_info->t_counts.t_tuples_returned++; \ |
| } while (0) |
| #define pgstat_count_heap_fetch(rel) \ |
| do { \ |
| if (pgstat_track_counts && (rel)->pgstat_info != NULL) \ |
| (rel)->pgstat_info->t_counts.t_tuples_fetched++; \ |
| } while (0) |
| |
| /* |
| #define pgstat_count_heap_insert(s) \ |
| do { \ |
| if (pgstat_track_counts) \ |
| (s)->pgstat_info->t_counts.t_tuples_inserted++; \ |
| } while (0) |
| #define pgstat_count_heap_update(s,h) \ |
| do { \ |
| if (pgstat_track_counts) \ |
| (s)->pgstat_info->t_counts.t_tuples_updated++; \ |
| } while (0) |
| #define pgstat_count_heap_delete(s) \ |
| do { \ |
| if (pgstat_track_counts) \ |
| (s)->pgstat_info->t_counts.t_tuples_deleted++; \ |
| } while (0) |
| */ |
| |
| #define pgstat_count_index_scan(rel) \ |
| do { \ |
| if (pgstat_track_counts && (rel)->pgstat_info != NULL) \ |
| (rel)->pgstat_info->t_counts.t_numscans++; \ |
| } while (0) |
| #define pgstat_count_index_tuples(rel, n) \ |
| do { \ |
| if (pgstat_track_counts && (rel)->pgstat_info != NULL) \ |
| (rel)->pgstat_info->t_counts.t_tuples_returned += (n); \ |
| } while (0) |
| #define pgstat_count_buffer_read(rel) \ |
| do { \ |
| if (pgstat_track_counts && (rel)->pgstat_info != NULL) \ |
| (rel)->pgstat_info->t_counts.t_blocks_fetched++; \ |
| } while (0) |
| #define pgstat_count_buffer_hit(rel) \ |
| do { \ |
| if (pgstat_track_counts && (rel)->pgstat_info != NULL) \ |
| (rel)->pgstat_info->t_counts.t_blocks_hit++; \ |
| } while (0) |
| |
| /* Resource queue statistics: */ |
| #define pgstat_count_queue_exec(p, q) \ |
| do { \ |
| if (pgstat_collect_queuelevel) \ |
| { \ |
| PgStat_StatPortalEntry *pentry; \ |
| \ |
| pentry = pgstat_getportalentry(p, q); \ |
| ((pentry)->queueentry).n_queries_exec++; \ |
| } \ |
| } while (0) |
| #define pgstat_record_start_queue_exec(p, q) \ |
| do { \ |
| if (pgstat_collect_queuelevel) \ |
| { \ |
| PgStat_StatPortalEntry *pentry; \ |
| \ |
| pentry = pgstat_getportalentry(p, q); \ |
| (pentry)->t_exec_start = time(NULL); \ |
| } \ |
| } while (0) |
| #define pgstat_record_end_queue_exec(p, q) \ |
| do { \ |
| if (pgstat_collect_queuelevel) \ |
| { \ |
| PgStat_StatPortalEntry *pentry; \ |
| \ |
| pentry = pgstat_getportalentry(p, q); \ |
| (pentry)->t_exec_end = time(NULL); \ |
| ((pentry)->queueentry).elapsed_exec += \ |
| (PgStat_Counter)((pentry)->t_exec_end - (pentry)->t_exec_start); \ |
| } \ |
| } while (0) |
| #define pgstat_count_queue_wait(p, q) \ |
| do { \ |
| if (pgstat_collect_queuelevel) \ |
| { \ |
| PgStat_StatPortalEntry *pentry; \ |
| \ |
| pentry = pgstat_getportalentry(p, q); \ |
| ((pentry)->queueentry).n_queries_wait++; \ |
| } \ |
| } while (0) |
| #define pgstat_record_start_queue_wait(p, q) \ |
| do { \ |
| if (pgstat_collect_queuelevel) \ |
| { \ |
| PgStat_StatPortalEntry *pentry; \ |
| \ |
| pentry = pgstat_getportalentry(p, q); \ |
| (pentry)->t_wait_start = time(NULL); \ |
| } \ |
| } while (0) |
| #define pgstat_record_end_queue_wait(p, q) \ |
| do { \ |
| if (pgstat_collect_queuelevel) \ |
| { \ |
| PgStat_StatPortalEntry *pentry; \ |
| \ |
| pentry = pgstat_getportalentry(p, q); \ |
| (pentry)->t_wait_end = time(NULL); \ |
| ((pentry)->queueentry).elapsed_wait += \ |
| (PgStat_Counter)((pentry)->t_wait_end - (pentry)->t_wait_start); \ |
| } \ |
| } while (0) |
| |
| extern void pgstat_count_heap_insert(Relation rel); |
| extern void pgstat_count_heap_update(Relation rel, bool hot); |
| extern void pgstat_count_heap_delete(Relation rel); |
| extern void pgstat_update_heap_dead_tuples(Relation rel, int delta); |
| |
| extern void pgstat_init_function_usage(FunctionCallInfoData *fcinfo, |
| PgStat_FunctionCallUsage *fcu); |
| extern void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, |
| bool finalize); |
| |
| extern void AtEOXact_PgStat(bool isCommit); |
| extern void AtEOSubXact_PgStat(bool isCommit, int nestDepth); |
| |
| extern void AtPrepare_PgStat(void); |
| extern void PostPrepare_PgStat(void); |
| |
| extern void pgstat_twophase_postcommit(TransactionId xid, uint16 info, |
| void *recdata, uint32 len); |
| extern void pgstat_twophase_postabort(TransactionId xid, uint16 info, |
| void *recdata, uint32 len); |
| |
| extern void pgstat_send_bgwriter(void); |
| |
| /* OLD? |
| extern void pgstat_count_xact_commit(void); |
| extern void pgstat_count_xact_rollback(void); |
| */ |
| |
| /* ---------- |
| * Support functions for the SQL-callable functions to |
| * generate the pgstat* views. |
| * ---------- |
| */ |
| extern PgStat_StatDBEntry *pgstat_fetch_stat_dbentry(Oid dbid); |
| extern PgStat_StatTabEntry *pgstat_fetch_stat_tabentry(Oid relid); |
| extern PgStat_StatQueueEntry *pgstat_fetch_stat_queueentry(Oid queueid); /* GPDB */ |
| extern PgBackendStatus *pgstat_fetch_stat_beentry(int beid); |
| extern PgStat_StatFuncEntry *pgstat_fetch_stat_funcentry(Oid funcid); |
| extern int pgstat_fetch_stat_numbackends(void); |
| extern PgStat_GlobalStats *pgstat_fetch_global(void); |
| |
| #endif /* PGSTAT_H */ |