Re: shared-memory based stats collector
| От | Kyotaro HORIGUCHI |
|---|---|
| Тема | Re: shared-memory based stats collector |
| Дата | |
| Msg-id | 20181002.160651.117284090.horiguchi.kyotaro@lab.ntt.co.jp обсуждение исходный текст |
| Ответ на | Re: shared-memory based stats collector (Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>) |
| Ответы |
Re: shared-memory based stats collector
(Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp>)
|
| Список | pgsql-hackers |
The previous patch doesn't work...
At Thu, 27 Sep 2018 22:00:49 +0900 (Tokyo Standard Time), Kyotaro HORIGUCHI <horiguchi.kyotaro@lab.ntt.co.jp> wrote in
<20180927.220049.168546206.horiguchi.kyotaro@lab.ntt.co.jp>
> - 0001 to 0006 is rebased version of v4.
> - 0007 adds conditional locking to dshash
>
> - 0008 is the no-UDP stats collector.
>
> If required lock is not acquired for some stats items, report
> funcions immediately return after storing the values locally. The
> stored values are merged with later calls. Explicitly calling
> pgstat_cleanup_pending_stat() at a convenient timing tries to
> apply the pending values, but the function is not called anywhere
> for now.
>
> stats collector process is used only to save and load saved stats
> files and create shared memory for stats. I'm going to remove
> stats collector.
>
> I'll continue working this way.
It doesn't work nor even compile since I failed to include some
changes. The atached v6-0008 at least compiles and words.
0001-0007 are not attached since they are still aplicable on
master head with offsets.
regards.
--
Kyotaro Horiguchi
NTT Open Source Software Center
From ffbe9d78239352df9ff9edac3e66675117703d88 Mon Sep 17 00:00:00 2001
From: Kyotaro Horiguchi <horiguchi.kyotaro@lab.ntt.co.jp>
Date: Thu, 27 Sep 2018 21:36:06 +0900
Subject: [PATCH 8/8] Ultra PoC of full-shared-memory stats collector.
This path is superultra PoC of full-shared-memory stats collector,
which means UDP is no longer involved in stats collector mechanism.
Some statistics items can be postponed when required lock is not
available, and they can be tried to clean up by calling
pgstat_cleanup_pending_stat() at a convenient time (not called in this
patch).
---
src/backend/access/transam/xlog.c | 4 +-
src/backend/postmaster/checkpointer.c | 8 +-
src/backend/postmaster/pgstat.c | 2424 ++++++++++++---------------------
src/backend/storage/buffer/bufmgr.c | 8 +-
src/backend/storage/lmgr/deadlock.c | 2 +-
src/backend/utils/adt/pgstatfuncs.c | 2 +-
src/include/pgstat.h | 357 +----
7 files changed, 936 insertions(+), 1869 deletions(-)
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 7375a78ffc..980c7e9e0e 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -8604,9 +8604,9 @@ LogCheckpointEnd(bool restartpoint)
&sync_secs, &sync_usecs);
/* Accumulate checkpoint timing summary data, in milliseconds. */
- BgWriterStats.m_checkpoint_write_time +=
+ BgWriterStats.checkpoint_write_time +=
write_secs * 1000 + write_usecs / 1000;
- BgWriterStats.m_checkpoint_sync_time +=
+ BgWriterStats.checkpoint_sync_time +=
sync_secs * 1000 + sync_usecs / 1000;
/*
diff --git a/src/backend/postmaster/checkpointer.c b/src/backend/postmaster/checkpointer.c
index 1a033093c5..62e1ee7ace 100644
--- a/src/backend/postmaster/checkpointer.c
+++ b/src/backend/postmaster/checkpointer.c
@@ -376,7 +376,7 @@ CheckpointerMain(void)
{
checkpoint_requested = false;
do_checkpoint = true;
- BgWriterStats.m_requested_checkpoints++;
+ BgWriterStats.requested_checkpoints++;
}
if (shutdown_requested)
{
@@ -402,7 +402,7 @@ CheckpointerMain(void)
if (elapsed_secs >= CheckPointTimeout)
{
if (!do_checkpoint)
- BgWriterStats.m_timed_checkpoints++;
+ BgWriterStats.timed_checkpoints++;
do_checkpoint = true;
flags |= CHECKPOINT_CAUSE_TIME;
}
@@ -1296,8 +1296,8 @@ AbsorbFsyncRequests(void)
LWLockAcquire(CheckpointerCommLock, LW_EXCLUSIVE);
/* Transfer stats counts into pending pgstats message */
- BgWriterStats.m_buf_written_backend += CheckpointerShmem->num_backend_writes;
- BgWriterStats.m_buf_fsync_backend += CheckpointerShmem->num_backend_fsync;
+ BgWriterStats.buf_written_backend += CheckpointerShmem->num_backend_writes;
+ BgWriterStats.buf_fsync_backend += CheckpointerShmem->num_backend_fsync;
CheckpointerShmem->num_backend_writes = 0;
CheckpointerShmem->num_backend_fsync = 0;
diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c
index a3d5f4856f..339425720f 100644
--- a/src/backend/postmaster/pgstat.c
+++ b/src/backend/postmaster/pgstat.c
@@ -93,6 +93,23 @@
#define PGSTAT_FUNCTION_HASH_SIZE 512
+#define PGSTAT_MAX_QUEUE_LEN 100
+
+/*
+ * Operation mode of pgstat_get_db_entry.
+ */
+#define PGSTAT_TABLE_READ 0
+#define PGSTAT_TABLE_WRITE 1
+#define PGSTAT_TABLE_CREATE 2
+#define PGSTAT_TABLE_NOWAIT 4
+
+typedef enum
+{
+ PGSTAT_TABLE_NOT_FOUND,
+ PGSTAT_TABLE_FOUND,
+ PGSTAT_TABLE_LOCK_FAILED
+} pg_stat_table_result_status;
+
/* ----------
* Total number of backends including auxiliary
*
@@ -119,16 +136,12 @@ int pgstat_track_activity_query_size = 1024;
* Stored directly in a stats message structure so it can be sent
* without needing to copy things around. We assume this inits to zeroes.
*/
-PgStat_MsgBgWriter BgWriterStats;
+PgStat_BgWriter BgWriterStats;
/* ----------
* Local data
* ----------
*/
-NON_EXEC_STATIC pgsocket pgStatSock = PGINVALID_SOCKET;
-
-static struct sockaddr_storage pgStatAddr;
-
static time_t last_pgstat_start_time;
static bool pgStatRunningInCollector = false;
@@ -212,12 +225,6 @@ static HTAB *pgStatTabHash = NULL;
*/
static HTAB *pgStatFunctions = NULL;
-/*
- * Indicates if backend has some function stats that it hasn't yet
- * sent to the collector.
- */
-static bool have_function_stats = false;
-
/*
* Tuple insertion/deletion counts for an open transaction can't be propagated
* into PgStat_TableStatus counters until we know if it is going to commit
@@ -311,7 +318,8 @@ static void pgstat_quickdie_handler(SIGNAL_ARGS);
static void pgstat_beshutdown_hook(int code, Datum arg);
static void pgstat_sighup_handler(SIGNAL_ARGS);
-static PgStat_StatDBEntry *pgstat_get_db_entry(Oid databaseid, bool create);
+static PgStat_StatDBEntry *pgstat_get_db_entry(Oid databaseid, int op,
+ pg_stat_table_result_status *status);
static PgStat_StatTabEntry *pgstat_get_tab_entry(dshash_table *table, Oid tableoid, bool create);
static void pgstat_write_statsfiles(void);
static void pgstat_write_db_statsfile(PgStat_StatDBEntry *dbentry);
@@ -323,10 +331,9 @@ static bool backend_snapshot_global_stats(void);
static PgStat_StatFuncEntry *backend_get_func_etnry(PgStat_StatDBEntry *dbent, Oid funcid, bool oneshot);
static void pgstat_read_current_status(void);
-static void pgstat_send_tabstat(PgStat_MsgTabstat *tsmsg);
static void pgstat_send_funcstats(void);
static HTAB *pgstat_collect_oids(Oid catalogid);
-
+static void reset_dbentry_counters(PgStat_StatDBEntry *dbentry);
static PgStat_TableStatus *get_tabstat_entry(Oid rel_id, bool isshared);
static void pgstat_setup_memcxt(void);
@@ -337,25 +344,13 @@ static const char *pgstat_get_wait_ipc(WaitEventIPC w);
static const char *pgstat_get_wait_timeout(WaitEventTimeout w);
static const char *pgstat_get_wait_io(WaitEventIO w);
-static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype);
-static void pgstat_send(void *msg, int len);
-
-static void pgstat_recv_tabstat(PgStat_MsgTabstat *msg, int len);
-static void pgstat_recv_tabpurge(PgStat_MsgTabpurge *msg, int len);
-static void pgstat_recv_dropdb(PgStat_MsgDropdb *msg, int len);
-static void pgstat_recv_resetcounter(PgStat_MsgResetcounter *msg, int len);
-static void pgstat_recv_resetsharedcounter(PgStat_MsgResetsharedcounter *msg, int len);
-static void pgstat_recv_resetsinglecounter(PgStat_MsgResetsinglecounter *msg, int len);
-static void pgstat_recv_autovac(PgStat_MsgAutovacStart *msg, int len);
-static void pgstat_recv_vacuum(PgStat_MsgVacuum *msg, int len);
-static void pgstat_recv_analyze(PgStat_MsgAnalyze *msg, int len);
-static void pgstat_recv_archiver(PgStat_MsgArchiver *msg, int len);
-static void pgstat_recv_bgwriter(PgStat_MsgBgWriter *msg, int len);
-static void pgstat_recv_funcstat(PgStat_MsgFuncstat *msg, int len);
-static void pgstat_recv_funcpurge(PgStat_MsgFuncpurge *msg, int len);
-static void pgstat_recv_recoveryconflict(PgStat_MsgRecoveryConflict *msg, int len);
-static void pgstat_recv_deadlock(PgStat_MsgDeadlock *msg, int len);
-static void pgstat_recv_tempfile(PgStat_MsgTempFile *msg, int len);
+static dshash_table *pgstat_update_dbentry(Oid dboid);
+static bool pgstat_update_tabentry(dshash_table *tabhash,
+ PgStat_TableStatus *stat);
+static bool pgstat_update_funcentry(dshash_table *funchash,
+ PgStat_BackendFunctionEntry *stat);
+static bool pgstat_tabpurge(Oid dboid, Oid taboid);
+static bool pgstat_funcpurge(Oid dboid, Oid funcoid);
/* ------------------------------------------------------------
* Public functions called from postmaster follow
@@ -374,280 +369,7 @@ static void pgstat_recv_tempfile(PgStat_MsgTempFile *msg, int len);
void
pgstat_init(void)
{
- ACCEPT_TYPE_ARG3 alen;
- struct addrinfo *addrs = NULL,
- *addr,
- hints;
- int ret;
- fd_set rset;
- struct timeval tv;
- char test_byte;
- int sel_res;
- int tries = 0;
-
-#define TESTBYTEVAL ((char) 199)
-
- /*
- * This static assertion verifies that we didn't mess up the calculations
- * involved in selecting maximum payload sizes for our UDP messages.
- * Because the only consequence of overrunning PGSTAT_MAX_MSG_SIZE would
- * be silent performance loss from fragmentation, it seems worth having a
- * compile-time cross-check that we didn't.
- */
- StaticAssertStmt(sizeof(PgStat_Msg) <= PGSTAT_MAX_MSG_SIZE,
- "maximum stats message size exceeds PGSTAT_MAX_MSG_SIZE");
-
- /*
- * Create the UDP socket for sending and receiving statistic messages
- */
- hints.ai_flags = AI_PASSIVE;
- hints.ai_family = AF_UNSPEC;
- hints.ai_socktype = SOCK_DGRAM;
- hints.ai_protocol = 0;
- hints.ai_addrlen = 0;
- hints.ai_addr = NULL;
- hints.ai_canonname = NULL;
- hints.ai_next = NULL;
- ret = pg_getaddrinfo_all("localhost", NULL, &hints, &addrs);
- if (ret || !addrs)
- {
- ereport(LOG,
- (errmsg("could not resolve \"localhost\": %s",
- gai_strerror(ret))));
- goto startup_failed;
- }
-
- /*
- * On some platforms, pg_getaddrinfo_all() may return multiple addresses
- * only one of which will actually work (eg, both IPv6 and IPv4 addresses
- * when kernel will reject IPv6). Worse, the failure may occur at the
- * bind() or perhaps even connect() stage. So we must loop through the
- * results till we find a working combination. We will generate LOG
- * messages, but no error, for bogus combinations.
- */
- for (addr = addrs; addr; addr = addr->ai_next)
- {
-#ifdef HAVE_UNIX_SOCKETS
- /* Ignore AF_UNIX sockets, if any are returned. */
- if (addr->ai_family == AF_UNIX)
- continue;
-#endif
-
- if (++tries > 1)
- ereport(LOG,
- (errmsg("trying another address for the statistics collector")));
-
- /*
- * Create the socket.
- */
- if ((pgStatSock = socket(addr->ai_family, SOCK_DGRAM, 0)) == PGINVALID_SOCKET)
- {
- ereport(LOG,
- (errcode_for_socket_access(),
- errmsg("could not create socket for statistics collector: %m")));
- continue;
- }
-
- /*
- * Bind it to a kernel assigned port on localhost and get the assigned
- * port via getsockname().
- */
- if (bind(pgStatSock, addr->ai_addr, addr->ai_addrlen) < 0)
- {
- ereport(LOG,
- (errcode_for_socket_access(),
- errmsg("could not bind socket for statistics collector: %m")));
- closesocket(pgStatSock);
- pgStatSock = PGINVALID_SOCKET;
- continue;
- }
-
- alen = sizeof(pgStatAddr);
- if (getsockname(pgStatSock, (struct sockaddr *) &pgStatAddr, &alen) < 0)
- {
- ereport(LOG,
- (errcode_for_socket_access(),
- errmsg("could not get address of socket for statistics collector: %m")));
- closesocket(pgStatSock);
- pgStatSock = PGINVALID_SOCKET;
- continue;
- }
-
- /*
- * Connect the socket to its own address. This saves a few cycles by
- * not having to respecify the target address on every send. This also
- * provides a kernel-level check that only packets from this same
- * address will be received.
- */
- if (connect(pgStatSock, (struct sockaddr *) &pgStatAddr, alen) < 0)
- {
- ereport(LOG,
- (errcode_for_socket_access(),
- errmsg("could not connect socket for statistics collector: %m")));
- closesocket(pgStatSock);
- pgStatSock = PGINVALID_SOCKET;
- continue;
- }
-
- /*
- * Try to send and receive a one-byte test message on the socket. This
- * is to catch situations where the socket can be created but will not
- * actually pass data (for instance, because kernel packet filtering
- * rules prevent it).
- */
- test_byte = TESTBYTEVAL;
-
-retry1:
- if (send(pgStatSock, &test_byte, 1, 0) != 1)
- {
- if (errno == EINTR)
- goto retry1; /* if interrupted, just retry */
- ereport(LOG,
- (errcode_for_socket_access(),
- errmsg("could not send test message on socket for statistics collector: %m")));
- closesocket(pgStatSock);
- pgStatSock = PGINVALID_SOCKET;
- continue;
- }
-
- /*
- * There could possibly be a little delay before the message can be
- * received. We arbitrarily allow up to half a second before deciding
- * it's broken.
- */
- for (;;) /* need a loop to handle EINTR */
- {
- FD_ZERO(&rset);
- FD_SET(pgStatSock, &rset);
-
- tv.tv_sec = 0;
- tv.tv_usec = 500000;
- sel_res = select(pgStatSock + 1, &rset, NULL, NULL, &tv);
- if (sel_res >= 0 || errno != EINTR)
- break;
- }
- if (sel_res < 0)
- {
- ereport(LOG,
- (errcode_for_socket_access(),
- errmsg("select() failed in statistics collector: %m")));
- closesocket(pgStatSock);
- pgStatSock = PGINVALID_SOCKET;
- continue;
- }
- if (sel_res == 0 || !FD_ISSET(pgStatSock, &rset))
- {
- /*
- * This is the case we actually think is likely, so take pains to
- * give a specific message for it.
- *
- * errno will not be set meaningfully here, so don't use it.
- */
- ereport(LOG,
- (errcode(ERRCODE_CONNECTION_FAILURE),
- errmsg("test message did not get through on socket for statistics collector")));
- closesocket(pgStatSock);
- pgStatSock = PGINVALID_SOCKET;
- continue;
- }
-
- test_byte++; /* just make sure variable is changed */
-
-retry2:
- if (recv(pgStatSock, &test_byte, 1, 0) != 1)
- {
- if (errno == EINTR)
- goto retry2; /* if interrupted, just retry */
- ereport(LOG,
- (errcode_for_socket_access(),
- errmsg("could not receive test message on socket for statistics collector: %m")));
- closesocket(pgStatSock);
- pgStatSock = PGINVALID_SOCKET;
- continue;
- }
-
- if (test_byte != TESTBYTEVAL) /* strictly paranoia ... */
- {
- ereport(LOG,
- (errcode(ERRCODE_INTERNAL_ERROR),
- errmsg("incorrect test message transmission on socket for statistics collector")));
- closesocket(pgStatSock);
- pgStatSock = PGINVALID_SOCKET;
- continue;
- }
-
- /* If we get here, we have a working socket */
- break;
- }
-
- /* Did we find a working address? */
- if (!addr || pgStatSock == PGINVALID_SOCKET)
- goto startup_failed;
-
- /*
- * Set the socket to non-blocking IO. This ensures that if the collector
- * falls behind, statistics messages will be discarded; backends won't
- * block waiting to send messages to the collector.
- */
- if (!pg_set_noblock(pgStatSock))
- {
- ereport(LOG,
- (errcode_for_socket_access(),
- errmsg("could not set statistics collector socket to nonblocking mode: %m")));
- goto startup_failed;
- }
-
- /*
- * Try to ensure that the socket's receive buffer is at least
- * PGSTAT_MIN_RCVBUF bytes, so that it won't easily overflow and lose
- * data. Use of UDP protocol means that we are willing to lose data under
- * heavy load, but we don't want it to happen just because of ridiculously
- * small default buffer sizes (such as 8KB on older Windows versions).
- */
- {
- int old_rcvbuf;
- int new_rcvbuf;
- ACCEPT_TYPE_ARG3 rcvbufsize = sizeof(old_rcvbuf);
-
- if (getsockopt(pgStatSock, SOL_SOCKET, SO_RCVBUF,
- (char *) &old_rcvbuf, &rcvbufsize) < 0)
- {
- elog(LOG, "getsockopt(SO_RCVBUF) failed: %m");
- /* if we can't get existing size, always try to set it */
- old_rcvbuf = 0;
- }
-
- new_rcvbuf = PGSTAT_MIN_RCVBUF;
- if (old_rcvbuf < new_rcvbuf)
- {
- if (setsockopt(pgStatSock, SOL_SOCKET, SO_RCVBUF,
- (char *) &new_rcvbuf, sizeof(new_rcvbuf)) < 0)
- elog(LOG, "setsockopt(SO_RCVBUF) failed: %m");
- }
- }
-
- pg_freeaddrinfo_all(hints.ai_family, addrs);
-
return;
-
-startup_failed:
- ereport(LOG,
- (errmsg("disabling statistics collector for lack of working socket")));
-
- if (addrs)
- pg_freeaddrinfo_all(hints.ai_family, addrs);
-
- if (pgStatSock != PGINVALID_SOCKET)
- closesocket(pgStatSock);
- pgStatSock = PGINVALID_SOCKET;
-
- /*
- * Adjust GUC variables to suppress useless activity, and for debugging
- * purposes (seeing track_counts off is a clue that we failed here). We
- * use PGC_S_OVERRIDE because there is no point in trying to turn it back
- * on from postgresql.conf without a restart.
- */
- SetConfigOption("track_counts", "off", PGC_INTERNAL, PGC_S_OVERRIDE);
}
/*
@@ -713,226 +435,6 @@ allow_immediate_pgstat_restart(void)
last_pgstat_start_time = 0;
}
-/* ------------------------------------------------------------
- * Public functions used by backends follow
- *------------------------------------------------------------
- */
-
-
-/* ----------
- * pgstat_report_stat() -
- *
- * Must be called by processes that performs DML: tcop/postgres.c, logical
- * receiver processes, SPI worker, etc. to send the so far collected
- * per-table and function usage statistics to the collector. Note that this
- * is called only when not within a transaction, so it is fair to use
- * transaction stop time as an approximation of current time.
- * ----------
- */
-void
-pgstat_report_stat(bool force)
-{
- /* we assume this inits to all zeroes: */
- static const PgStat_TableCounts all_zeroes;
- static TimestampTz last_report = 0;
-
- TimestampTz now;
- PgStat_MsgTabstat regular_msg;
- PgStat_MsgTabstat shared_msg;
- TabStatusArray *tsa;
- int i;
-
- /* Don't expend a clock check if nothing to do */
- if ((pgStatTabList == NULL || pgStatTabList->tsa_used == 0) &&
- pgStatXactCommit == 0 && pgStatXactRollback == 0 &&
- !have_function_stats)
- return;
-
- /*
- * Don't send a message unless it's been at least PGSTAT_STAT_INTERVAL
- * msec since we last sent one, or the caller wants to force stats out.
- */
- now = GetCurrentTransactionStopTimestamp();
- if (!force &&
- !TimestampDifferenceExceeds(last_report, now, PGSTAT_STAT_INTERVAL))
- return;
- last_report = now;
-
- /*
- * Destroy pgStatTabHash before we start invalidating PgStat_TableEntry
- * entries it points to. (Should we fail partway through the loop below,
- * it's okay to have removed the hashtable already --- the only
- * consequence is we'd get multiple entries for the same table in the
- * pgStatTabList, and that's safe.)
- */
- if (pgStatTabHash)
- hash_destroy(pgStatTabHash);
- pgStatTabHash = NULL;
-
- /*
- * Scan through the TabStatusArray struct(s) to find tables that actually
- * have counts, and build messages to send. We have to separate shared
- * relations from regular ones because the databaseid field in the message
- * header has to depend on that.
- */
- regular_msg.m_databaseid = MyDatabaseId;
- shared_msg.m_databaseid = InvalidOid;
- regular_msg.m_nentries = 0;
- shared_msg.m_nentries = 0;
-
- for (tsa = pgStatTabList; tsa != NULL; tsa = tsa->tsa_next)
- {
- for (i = 0; i < tsa->tsa_used; i++)
- {
- PgStat_TableStatus *entry = &tsa->tsa_entries[i];
- PgStat_MsgTabstat *this_msg;
- PgStat_TableEntry *this_ent;
-
- /* Shouldn't have any pending transaction-dependent counts */
- Assert(entry->trans == NULL);
-
- /*
- * Ignore entries that didn't accumulate any actual counts, such
- * as indexes that were opened by the planner but not used.
- */
- if (memcmp(&entry->t_counts, &all_zeroes,
- sizeof(PgStat_TableCounts)) == 0)
- continue;
-
- /*
- * OK, insert data into the appropriate message, and send if full.
- */
- this_msg = entry->t_shared ? &shared_msg : ®ular_msg;
- this_ent = &this_msg->m_entry[this_msg->m_nentries];
- this_ent->t_id = entry->t_id;
- memcpy(&this_ent->t_counts, &entry->t_counts,
- sizeof(PgStat_TableCounts));
- if (++this_msg->m_nentries >= PGSTAT_NUM_TABENTRIES)
- {
- pgstat_send_tabstat(this_msg);
- this_msg->m_nentries = 0;
- }
- }
- /* zero out TableStatus structs after use */
- MemSet(tsa->tsa_entries, 0,
- tsa->tsa_used * sizeof(PgStat_TableStatus));
- tsa->tsa_used = 0;
- }
-
- /*
- * Send partial messages. Make sure that any pending xact commit/abort
- * gets counted, even if there are no table stats to send.
- */
- if (regular_msg.m_nentries > 0 ||
- pgStatXactCommit > 0 || pgStatXactRollback > 0)
- pgstat_send_tabstat(®ular_msg);
- if (shared_msg.m_nentries > 0)
- pgstat_send_tabstat(&shared_msg);
-
- /* Now, send function statistics */
- pgstat_send_funcstats();
-}
-
-/*
- * Subroutine for pgstat_report_stat: finish and send a tabstat message
- */
-static void
-pgstat_send_tabstat(PgStat_MsgTabstat *tsmsg)
-{
- int n;
- int len;
-
- /* It's unlikely we'd get here with no socket, but maybe not impossible */
- if (pgStatSock == PGINVALID_SOCKET)
- return;
-
- /*
- * Report and reset accumulated xact commit/rollback and I/O timings
- * whenever we send a normal tabstat message
- */
- if (OidIsValid(tsmsg->m_databaseid))
- {
- tsmsg->m_xact_commit = pgStatXactCommit;
- tsmsg->m_xact_rollback = pgStatXactRollback;
- tsmsg->m_block_read_time = pgStatBlockReadTime;
- tsmsg->m_block_write_time = pgStatBlockWriteTime;
- pgStatXactCommit = 0;
- pgStatXactRollback = 0;
- pgStatBlockReadTime = 0;
- pgStatBlockWriteTime = 0;
- }
- else
- {
- tsmsg->m_xact_commit = 0;
- tsmsg->m_xact_rollback = 0;
- tsmsg->m_block_read_time = 0;
- tsmsg->m_block_write_time = 0;
- }
-
- n = tsmsg->m_nentries;
- len = offsetof(PgStat_MsgTabstat, m_entry[0]) +
- n * sizeof(PgStat_TableEntry);
-
- pgstat_setheader(&tsmsg->m_hdr, PGSTAT_MTYPE_TABSTAT);
- pgstat_send(tsmsg, len);
-}
-
-/*
- * Subroutine for pgstat_report_stat: populate and send a function stat message
- */
-static void
-pgstat_send_funcstats(void)
-{
- /* we assume this inits to all zeroes: */
- static const PgStat_FunctionCounts all_zeroes;
-
- PgStat_MsgFuncstat msg;
- PgStat_BackendFunctionEntry *entry;
- HASH_SEQ_STATUS fstat;
-
- if (pgStatFunctions == NULL)
- return;
-
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_FUNCSTAT);
- msg.m_databaseid = MyDatabaseId;
- msg.m_nentries = 0;
-
- hash_seq_init(&fstat, pgStatFunctions);
- while ((entry = (PgStat_BackendFunctionEntry *) hash_seq_search(&fstat)) != NULL)
- {
- PgStat_FunctionEntry *m_ent;
-
- /* Skip it if no counts accumulated since last time */
- if (memcmp(&entry->f_counts, &all_zeroes,
- sizeof(PgStat_FunctionCounts)) == 0)
- continue;
-
- /* need to convert format of time accumulators */
- m_ent = &msg.m_entry[msg.m_nentries];
- m_ent->f_id = entry->f_id;
- m_ent->f_numcalls = entry->f_counts.f_numcalls;
- m_ent->f_total_time = INSTR_TIME_GET_MICROSEC(entry->f_counts.f_total_time);
- m_ent->f_self_time = INSTR_TIME_GET_MICROSEC(entry->f_counts.f_self_time);
-
- if (++msg.m_nentries >= PGSTAT_NUM_FUNCENTRIES)
- {
- pgstat_send(&msg, offsetof(PgStat_MsgFuncstat, m_entry[0]) +
- msg.m_nentries * sizeof(PgStat_FunctionEntry));
- msg.m_nentries = 0;
- }
-
- /* reset the entry's counts */
- MemSet(&entry->f_counts, 0, sizeof(PgStat_FunctionCounts));
- }
-
- if (msg.m_nentries > 0)
- pgstat_send(&msg, offsetof(PgStat_MsgFuncstat, m_entry[0]) +
- msg.m_nentries * sizeof(PgStat_FunctionEntry));
-
- have_function_stats = false;
-}
-
-
/* ----------
* pgstat_attach_shared_stats() -
*
@@ -1008,6 +510,225 @@ pgstat_create_shared_stats(void)
LWLockRelease(StatsLock);
}
+
+/* ------------------------------------------------------------
+ * Public functions used by backends follow
+ *------------------------------------------------------------
+ */
+static bool pgstat_pending_tabstats = false;
+static bool pgstat_pending_funcstats = false;
+static bool pgstat_pending_vacstats = false;
+static bool pgstat_pending_dropdb = false;
+static bool pgstat_pending_resetcounter = false;
+static bool pgstat_pending_resetsharedcounter = false;
+static bool pgstat_pending_resetsinglecounter = false;
+static bool pgstat_pending_autovac = false;
+static bool pgstat_pending_vacuum = false;
+static bool pgstat_pending_analyze = false;
+static bool pgstat_pending_recoveryconflict = false;
+static bool pgstat_pending_deadlock = false;
+static bool pgstat_pending_tempfile = false;
+
+void
+pgstat_cleanup_pending_stat(void)
+{
+ if (pgstat_pending_tabstats)
+ pgstat_report_stat(true);
+ if (pgstat_pending_funcstats)
+ pgstat_send_funcstats();
+ if (pgstat_pending_vacstats)
+ pgstat_vacuum_stat();
+ if (pgstat_pending_dropdb)
+ pgstat_drop_database(InvalidOid);
+ if (pgstat_pending_resetcounter)
+ pgstat_reset_counters();
+ if (pgstat_pending_resetsharedcounter)
+ pgstat_reset_shared_counters(NULL);
+ if (pgstat_pending_resetsinglecounter)
+ pgstat_reset_single_counter(InvalidOid, 0);
+ if (pgstat_pending_autovac)
+ pgstat_report_autovac(InvalidOid);
+ if (pgstat_pending_vacuum)
+ pgstat_report_vacuum(InvalidOid, false, 0, 0);
+ if (pgstat_pending_analyze)
+ pgstat_report_analyze(NULL, 0, 0, false);
+ if (pgstat_pending_recoveryconflict)
+ pgstat_report_recovery_conflict(-1);
+ if (pgstat_pending_deadlock)
+ pgstat_report_deadlock(true);
+ if (pgstat_pending_tempfile)
+ pgstat_report_tempfile(0);
+}
+
+/* ----------
+ * pgstat_report_stat() -
+ *
+ * Must be called by processes that performs DML: tcop/postgres.c, logical
+ * receiver processes, SPI worker, etc. to send the so far collected
+ * per-table and function usage statistics to the collector. Note that this
+ * is called only when not within a transaction, so it is fair to use
+ * transaction stop time as an approximation of current time.
+ * ----------
+ */
+void
+pgstat_report_stat(bool force)
+{
+ /* we assume this inits to all zeroes: */
+ static const PgStat_TableCounts all_zeroes;
+ static TimestampTz last_report = 0;
+ TimestampTz now;
+ TabStatusArray *tsa;
+ int i;
+ dshash_table *shared_tabhash = NULL;
+ dshash_table *regular_tabhash = NULL;
+
+ /* Don't expend a clock check if nothing to do */
+ if (!pgstat_pending_tabstats &&
+ (pgStatTabList == NULL || pgStatTabList->tsa_used == 0) &&
+ pgStatXactCommit == 0 && pgStatXactRollback == 0 &&
+ !pgstat_pending_funcstats)
+ return;
+
+ /*
+ * Don't update shared stats aunless it's been at least
+ * PGSTAT_STAT_INTERVAL msec since we last sent one, or the caller wants
+ * to force stats out.
+ */
+ now = GetCurrentTransactionStopTimestamp();
+ if (!force &&
+ !TimestampDifferenceExceeds(last_report, now, PGSTAT_STAT_INTERVAL))
+ return;
+ last_report = now;
+
+ /*
+ * Destroy pgStatTabHash before we start invalidating PgStat_TableEntry
+ * entries it points to. (Should we fail partway through the loop below,
+ * it's okay to have removed the hashtable already --- the only
+ * consequence is we'd get multiple entries for the same table in the
+ * pgStatTabList, and that's safe.)
+ */
+ if (pgStatTabHash)
+ hash_destroy(pgStatTabHash);
+ pgStatTabHash = NULL;
+
+ pgstat_pending_tabstats = false;
+ for (tsa = pgStatTabList; tsa != NULL; tsa = tsa->tsa_next)
+ {
+ int move_skipped_to = 0;
+
+ for (i = 0; i < tsa->tsa_used; i++)
+ {
+ PgStat_TableStatus *entry = &tsa->tsa_entries[i];
+ dshash_table *tabhash;
+
+ /* Shouldn't have any pending transaction-dependent counts */
+ Assert(entry->trans == NULL);
+
+ /*
+ * Ignore entries that didn't accumulate any actual counts, such
+ * as indexes that were opened by the planner but not used.
+ */
+ if (memcmp(&entry->t_counts, &all_zeroes,
+ sizeof(PgStat_TableCounts)) != 0)
+ {
+ /*
+ * OK, insert data into the appropriate message, and send if
+ * full.
+ */
+ if (entry->t_shared)
+ {
+ if (!shared_tabhash)
+ shared_tabhash = pgstat_update_dbentry(InvalidOid);
+ tabhash = shared_tabhash;
+ }
+ else
+ {
+ if (!regular_tabhash)
+ regular_tabhash = pgstat_update_dbentry(MyDatabaseId);
+ tabhash = regular_tabhash;
+ }
+
+ /*
+ * If this entry failed to be processed, leave this entry for
+ * the next turn. The enties should be in head-filled manner.
+ */
+ if (!pgstat_update_tabentry(tabhash, entry))
+ {
+ if (move_skipped_to < i)
+ memmove(&tsa->tsa_entries[move_skipped_to],
+ &tsa->tsa_entries[i],
+ sizeof(PgStat_TableStatus));
+ move_skipped_to++;
+ }
+ }
+ }
+
+ /* notify unapplied items are exists */
+ if (move_skipped_to > 0)
+ pgstat_pending_tabstats = true;
+
+ tsa->tsa_used = move_skipped_to;
+ /* zero out TableStatus structs after use */
+ MemSet(&tsa->tsa_entries[tsa->tsa_used], 0,
+ (TABSTAT_QUANTUM - tsa->tsa_used) * sizeof(PgStat_TableStatus));
+ }
+
+ /* Now, send function statistics */
+ pgstat_send_funcstats();
+}
+
+/*
+ * Subroutine for pgstat_report_stat: populate and send a function stat message
+ */
+static void
+pgstat_send_funcstats(void)
+{
+ /* we assume this inits to all zeroes: */
+ static const PgStat_FunctionCounts all_zeroes;
+
+ PgStat_BackendFunctionEntry *entry;
+ HASH_SEQ_STATUS fstat;
+ PgStat_StatDBEntry *dbentry;
+ pg_stat_table_result_status status;
+ dshash_table *funchash;
+
+ if (pgStatFunctions == NULL)
+ return;
+
+ pgstat_pending_funcstats = false;
+
+ dbentry = pgstat_get_db_entry(MyDatabaseId,
+ PGSTAT_TABLE_WRITE
+ | PGSTAT_TABLE_CREATE
+ | PGSTAT_TABLE_NOWAIT,
+ &status);
+
+ if (status == PGSTAT_TABLE_LOCK_FAILED)
+ return;
+
+ funchash = dshash_attach(area, &dsh_funcparams, dbentry->functions, 0);
+
+ hash_seq_init(&fstat, pgStatFunctions);
+ while ((entry = (PgStat_BackendFunctionEntry *) hash_seq_search(&fstat)) != NULL)
+ {
+ /* Skip it if no counts accumulated since last time */
+ if (memcmp(&entry->f_counts, &all_zeroes,
+ sizeof(PgStat_FunctionCounts)) == 0)
+ continue;
+
+ if (pgstat_update_funcentry(funchash, entry))
+ {
+ /* reset the entry's counts */
+ MemSet(&entry->f_counts, 0, sizeof(PgStat_FunctionCounts));
+ }
+ else
+ pgstat_pending_funcstats = true;
+ }
+
+ dshash_release_lock(db_stats, dbentry);
+}
+
+
/* ----------
* pgstat_vacuum_stat() -
*
@@ -1018,17 +739,13 @@ void
pgstat_vacuum_stat(void)
{
HTAB *oidtab;
- PgStat_MsgTabpurge msg;
- PgStat_MsgFuncpurge f_msg;
dshash_table *dshtable;
dshash_seq_status dshstat;
PgStat_StatDBEntry *dbentry;
PgStat_StatTabEntry *tabentry;
PgStat_StatFuncEntry *funcentry;
- int len;
-
- if (pgStatSock == PGINVALID_SOCKET)
- return;
+ pg_stat_table_result_status status;
+ bool no_pending_stats;
/* If not done for this transaction, take a snapshot of stats */
if (!backend_snapshot_global_stats())
@@ -1060,11 +777,15 @@ pgstat_vacuum_stat(void)
/* Clean up */
hash_destroy(oidtab);
+ pgstat_pending_vacstats = true;
+
/*
* Lookup our own database entry; if not found, nothing more to do.
*/
- dbentry = backend_get_db_entry(MyDatabaseId, true);
- if (dbentry == NULL)
+ dbentry = pgstat_get_db_entry(MyDatabaseId,
+ PGSTAT_TABLE_WRITE | PGSTAT_TABLE_NOWAIT,
+ &status);
+ if (status == PGSTAT_TABLE_LOCK_FAILED)
return;
/*
@@ -1072,17 +793,13 @@ pgstat_vacuum_stat(void)
*/
oidtab = pgstat_collect_oids(RelationRelationId);
- /*
- * Initialize our messages table counter to zero
- */
- msg.m_nentries = 0;
-
/*
* Check for all tables listed in stats hashtable if they still exist.
* Stats cache is useless here so directly search the shared hash.
*/
dshtable = dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
dshash_seq_init(&dshstat, dshtable, false);
+ no_pending_stats = true;
while ((tabentry = (PgStat_StatTabEntry *) dshash_seq_next(&dshstat)) != NULL)
{
Oid tabid = tabentry->tableid;
@@ -1092,41 +809,11 @@ pgstat_vacuum_stat(void)
if (hash_search(oidtab, (void *) &tabid, HASH_FIND, NULL) != NULL)
continue;
- /*
- * Not there, so add this table's Oid to the message
- */
- msg.m_tableid[msg.m_nentries++] = tabid;
-
- /*
- * If the message is full, send it out and reinitialize to empty
- */
- if (msg.m_nentries >= PGSTAT_NUM_TABPURGE)
- {
- len = offsetof(PgStat_MsgTabpurge, m_tableid[0])
- + msg.m_nentries * sizeof(Oid);
-
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
- msg.m_databaseid = MyDatabaseId;
- pgstat_send(&msg, len);
-
- msg.m_nentries = 0;
- }
+ /* Not there, so purge this table */
+ if (!pgstat_tabpurge(MyDatabaseId, tabid))
+ no_pending_stats = false;
}
dshash_detach(dshtable);
-
- /*
- * Send the rest
- */
- if (msg.m_nentries > 0)
- {
- len = offsetof(PgStat_MsgTabpurge, m_tableid[0])
- + msg.m_nentries * sizeof(Oid);
-
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
- msg.m_databaseid = MyDatabaseId;
- pgstat_send(&msg, len);
- }
-
/* Clean up */
hash_destroy(oidtab);
@@ -1139,10 +826,6 @@ pgstat_vacuum_stat(void)
{
oidtab = pgstat_collect_oids(ProcedureRelationId);
- pgstat_setheader(&f_msg.m_hdr, PGSTAT_MTYPE_FUNCPURGE);
- f_msg.m_databaseid = MyDatabaseId;
- f_msg.m_nentries = 0;
-
dshash_seq_init(&dshstat, dshtable, false);
while ((funcentry = (PgStat_StatFuncEntry *) dshash_seq_next(&dshstat)) != NULL)
{
@@ -1153,39 +836,17 @@ pgstat_vacuum_stat(void)
if (hash_search(oidtab, (void *) &funcid, HASH_FIND, NULL) != NULL)
continue;
- /*
- * Not there, so add this function's Oid to the message
- */
- f_msg.m_functionid[f_msg.m_nentries++] = funcid;
-
- /*
- * If the message is full, send it out and reinitialize to empty
- */
- if (f_msg.m_nentries >= PGSTAT_NUM_FUNCPURGE)
- {
- len = offsetof(PgStat_MsgFuncpurge, m_functionid[0])
- + f_msg.m_nentries * sizeof(Oid);
-
- pgstat_send(&f_msg, len);
-
- f_msg.m_nentries = 0;
- }
+ /* Not there, so move this function */
+ if (!pgstat_funcpurge(MyDatabaseId, funcid))
+ no_pending_stats = false;
}
-
- /*
- * Send the rest
- */
- if (f_msg.m_nentries > 0)
- {
- len = offsetof(PgStat_MsgFuncpurge, m_functionid[0])
- + f_msg.m_nentries * sizeof(Oid);
-
- pgstat_send(&f_msg, len);
- }
-
hash_destroy(oidtab);
}
dshash_detach(dshtable);
+ dshash_release_lock(db_stats, dbentry);
+
+ if (no_pending_stats)
+ pgstat_pending_vacstats = false;
}
@@ -1247,50 +908,69 @@ pgstat_collect_oids(Oid catalogid)
void
pgstat_drop_database(Oid databaseid)
{
- PgStat_MsgDropdb msg;
+ static List *pending_dbid = NIL;
+ List *left_dbid = NIL;
+ PgStat_StatDBEntry *dbentry;
+ pg_stat_table_result_status status;
+ ListCell *lc;
- if (pgStatSock == PGINVALID_SOCKET)
+ if (OidIsValid(databaseid))
+ pending_dbid = lappend_oid(pending_dbid, databaseid);
+ pgstat_pending_dropdb = true;
+
+ if (db_stats == NULL)
return;
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DROPDB);
- msg.m_databaseid = databaseid;
- pgstat_send(&msg, sizeof(msg));
+ foreach (lc, pending_dbid)
+ {
+ Oid dbid = lfirst_oid(lc);
+
+ /*
+ * Lookup the database in the hashtable.
+ */
+ dbentry = pgstat_get_db_entry(dbid,
+ PGSTAT_TABLE_WRITE | PGSTAT_TABLE_NOWAIT,
+ &status);
+
+ /* skip on lock failure */
+ if (status == PGSTAT_TABLE_LOCK_FAILED)
+ {
+ left_dbid = lappend_oid(left_dbid, dbid);
+ continue;
+ }
+
+ /*
+ * If found, remove it (along with the db statfile).
+ */
+ if (dbentry)
+ {
+ if (dbentry->tables != DSM_HANDLE_INVALID)
+ {
+ dshash_table *tbl =
+ dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
+ dshash_destroy(tbl);
+ }
+ if (dbentry->functions != DSM_HANDLE_INVALID)
+ {
+ dshash_table *tbl =
+ dshash_attach(area, &dsh_funcparams, dbentry->functions, 0);
+ dshash_destroy(tbl);
+ }
+
+
+ dshash_delete_entry(db_stats, (void *)dbentry);
+ }
+ }
+
+ list_free(pending_dbid);
+ pending_dbid = left_dbid;
+
+ /* we're done if no pending database ids */
+ if (list_length(pending_dbid) == 0)
+ pgstat_pending_dropdb = false;
}
-/* ----------
- * pgstat_drop_relation() -
- *
- * Tell the collector that we just dropped a relation.
- * (If the message gets lost, we will still clean the dead entry eventually
- * via future invocations of pgstat_vacuum_stat().)
- *
- * Currently not used for lack of any good place to call it; we rely
- * entirely on pgstat_vacuum_stat() to clean out stats for dead rels.
- * ----------
- */
-#ifdef NOT_USED
-void
-pgstat_drop_relation(Oid relid)
-{
- PgStat_MsgTabpurge msg;
- int len;
-
- if (pgStatSock == PGINVALID_SOCKET)
- return;
-
- msg.m_tableid[0] = relid;
- msg.m_nentries = 1;
-
- len = offsetof(PgStat_MsgTabpurge, m_tableid[0]) + sizeof(Oid);
-
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
- msg.m_databaseid = MyDatabaseId;
- pgstat_send(&msg, len);
-}
-#endif /* NOT_USED */
-
-
/* ----------
* pgstat_reset_counters() -
*
@@ -1303,14 +983,59 @@ pgstat_drop_relation(Oid relid)
void
pgstat_reset_counters(void)
{
- PgStat_MsgResetcounter msg;
+ PgStat_StatDBEntry *dbentry;
+ pg_stat_table_result_status status;
- if (pgStatSock == PGINVALID_SOCKET)
+ pgstat_pending_resetcounter = true;
+
+ if (db_stats == NULL)
return;
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETCOUNTER);
- msg.m_databaseid = MyDatabaseId;
- pgstat_send(&msg, sizeof(msg));
+ /*
+ * Lookup the database in the hashtable. Nothing to do if not there.
+ */
+ dbentry = pgstat_get_db_entry(MyDatabaseId,
+ PGSTAT_TABLE_WRITE | PGSTAT_TABLE_NOWAIT,
+ &status);
+
+ if (status == PGSTAT_TABLE_LOCK_FAILED)
+ return;
+
+ if (!dbentry)
+ {
+ pgstat_pending_resetcounter = false;
+ return;
+ }
+
+ /*
+ * We simply throw away all the database's table entries by recreating a
+ * new hash table for them.
+ */
+ if (dbentry->tables != DSM_HANDLE_INVALID)
+ {
+ dshash_table *t =
+ dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
+ dshash_destroy(t);
+ dbentry->tables = DSM_HANDLE_INVALID;
+ }
+ if (dbentry->functions != DSM_HANDLE_INVALID)
+ {
+ dshash_table *t =
+ dshash_attach(area, &dsh_funcparams, dbentry->functions, 0);
+ dshash_destroy(t);
+ dbentry->functions = DSM_HANDLE_INVALID;
+ }
+
+ /*
+ * Reset database-level stats, too. This creates empty hash tables for
+ * tables and functions.
+ */
+ reset_dbentry_counters(dbentry);
+
+ dshash_release_lock(db_stats, dbentry);
+
+ /* we're done */
+ pgstat_pending_resetcounter = false;
}
/* ----------
@@ -1325,23 +1050,53 @@ pgstat_reset_counters(void)
void
pgstat_reset_shared_counters(const char *target)
{
- PgStat_MsgResetsharedcounter msg;
-
- if (pgStatSock == PGINVALID_SOCKET)
- return;
+ static bool archiver_pending = false;
+ static bool bgwriter_pending = false;
+ bool have_lock = false;
if (strcmp(target, "archiver") == 0)
- msg.m_resettarget = RESET_ARCHIVER;
+ {
+ archiver_pending = true;
+ }
else if (strcmp(target, "bgwriter") == 0)
- msg.m_resettarget = RESET_BGWRITER;
- else
+ {
+ bgwriter_pending = true;
+ }
+ else if (target != NULL)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("unrecognized reset target: \"%s\"", target),
errhint("Target must be \"archiver\" or \"bgwriter\".")));
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETSHAREDCOUNTER);
- pgstat_send(&msg, sizeof(msg));
+ pgstat_pending_resetsharedcounter = true;
+
+ if (db_stats == NULL)
+ return;
+
+ /* Reset the archiver statistics for the cluster. */
+ if (archiver_pending && LWLockConditionalAcquire(StatsLock, LW_EXCLUSIVE))
+ {
+ memset(&shared_archiverStats, 0, sizeof(shared_archiverStats));
+ shared_archiverStats->stat_reset_timestamp = GetCurrentTimestamp();
+ archiver_pending = false;
+ have_lock = true;
+ }
+
+ if (bgwriter_pending &&
+ (have_lock || LWLockConditionalAcquire(StatsLock, LW_EXCLUSIVE)))
+ {
+ /* Reset the global background writer statistics for the cluster. */
+ memset(&shared_globalStats, 0, sizeof(shared_globalStats));
+ shared_globalStats->stat_reset_timestamp = GetCurrentTimestamp();
+ bgwriter_pending = false;
+ have_lock = true;
+ }
+
+ if (have_lock)
+ LWLockRelease(StatsLock);
+
+ /* notify any pending update */
+ pgstat_pending_resetsharedcounter = (archiver_pending || bgwriter_pending);
}
/* ----------
@@ -1356,17 +1111,37 @@ pgstat_reset_shared_counters(const char *target)
void
pgstat_reset_single_counter(Oid objoid, PgStat_Single_Reset_Type type)
{
- PgStat_MsgResetsinglecounter msg;
+ PgStat_StatDBEntry *dbentry;
- if (pgStatSock == PGINVALID_SOCKET)
+ /* Don't defer */
+
+ if (db_stats == NULL)
return;
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETSINGLECOUNTER);
- msg.m_databaseid = MyDatabaseId;
- msg.m_resettype = type;
- msg.m_objectid = objoid;
+ dbentry = pgstat_get_db_entry(MyDatabaseId, PGSTAT_TABLE_WRITE, NULL);
- pgstat_send(&msg, sizeof(msg));
+ if (!dbentry)
+ return;
+
+ /* Set the reset timestamp for the whole database */
+ dbentry->stat_reset_timestamp = GetCurrentTimestamp();
+
+ /* Remove object if it exists, ignore it if not */
+ if (type == RESET_TABLE)
+ {
+ dshash_table *t =
+ dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
+ dshash_delete_key(t, (void *) &objoid);
+ }
+
+ if (type == RESET_FUNCTION)
+ {
+ dshash_table *t =
+ dshash_attach(area, &dsh_funcparams, dbentry->functions, 0);
+ dshash_delete_key(t, (void *) &objoid);
+ }
+
+ dshash_release_lock(db_stats, dbentry);
}
/* ----------
@@ -1380,16 +1155,23 @@ pgstat_reset_single_counter(Oid objoid, PgStat_Single_Reset_Type type)
void
pgstat_report_autovac(Oid dboid)
{
- PgStat_MsgAutovacStart msg;
+ PgStat_StatDBEntry *dbentry;
- if (pgStatSock == PGINVALID_SOCKET)
+ /* Don't defer */
+
+ if (db_stats == NULL)
return;
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_AUTOVAC_START);
- msg.m_databaseid = dboid;
- msg.m_start_time = GetCurrentTimestamp();
+ /*
+ * Store the last autovacuum time in the database's hashtable entry.
+ */
+ dbentry = pgstat_get_db_entry(dboid,
+ PGSTAT_TABLE_WRITE | PGSTAT_TABLE_CREATE,
+ NULL);
- pgstat_send(&msg, sizeof(msg));
+ dbentry->last_autovac_time = GetCurrentTimestamp();
+
+ dshash_release_lock(db_stats, dbentry);
}
@@ -1403,19 +1185,43 @@ void
pgstat_report_vacuum(Oid tableoid, bool shared,
PgStat_Counter livetuples, PgStat_Counter deadtuples)
{
- PgStat_MsgVacuum msg;
+ Oid dboid;
+ PgStat_StatDBEntry *dbentry;
+ PgStat_StatTabEntry *tabentry;
+ dshash_table *table;
- if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
+ /* Don't defer */
+
+ if (db_stats == NULL || !pgstat_track_counts)
return;
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_VACUUM);
- msg.m_databaseid = shared ? InvalidOid : MyDatabaseId;
- msg.m_tableoid = tableoid;
- msg.m_autovacuum = IsAutoVacuumWorkerProcess();
- msg.m_vacuumtime = GetCurrentTimestamp();
- msg.m_live_tuples = livetuples;
- msg.m_dead_tuples = deadtuples;
- pgstat_send(&msg, sizeof(msg));
+ dboid = shared ? InvalidOid : MyDatabaseId;
+
+ /*
+ * Store the data in the table's hashtable entry.
+ */
+ dbentry = pgstat_get_db_entry(dboid,
+ PGSTAT_TABLE_WRITE | PGSTAT_TABLE_CREATE,
+ NULL);
+ table = dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
+ tabentry = pgstat_get_tab_entry(table, tableoid, true);
+
+ tabentry->n_live_tuples = livetuples;
+ tabentry->n_dead_tuples = deadtuples;
+
+ if (IsAutoVacuumWorkerProcess())
+ {
+ tabentry->autovac_vacuum_timestamp = GetCurrentTimestamp();
+ tabentry->autovac_vacuum_count++;
+ }
+ else
+ {
+ tabentry->vacuum_timestamp = GetCurrentTimestamp();
+ tabentry->vacuum_count++;
+ }
+ dshash_release_lock(table, tabentry);
+ dshash_detach(table);
+ dshash_release_lock(db_stats, dbentry);
}
/* --------
@@ -1432,9 +1238,14 @@ pgstat_report_analyze(Relation rel,
PgStat_Counter livetuples, PgStat_Counter deadtuples,
bool resetcounter)
{
- PgStat_MsgAnalyze msg;
+ Oid dboid;
+ PgStat_StatDBEntry *dbentry;
+ PgStat_StatTabEntry *tabentry;
+ dshash_table *table;
- if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
+ /* Don't defer */
+
+ if (db_stats == NULL || !pgstat_track_counts)
return;
/*
@@ -1463,15 +1274,42 @@ pgstat_report_analyze(Relation rel,
deadtuples = Max(deadtuples, 0);
}
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_ANALYZE);
- msg.m_databaseid = rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId;
- msg.m_tableoid = RelationGetRelid(rel);
- msg.m_autovacuum = IsAutoVacuumWorkerProcess();
- msg.m_resetcounter = resetcounter;
- msg.m_analyzetime = GetCurrentTimestamp();
- msg.m_live_tuples = livetuples;
- msg.m_dead_tuples = deadtuples;
- pgstat_send(&msg, sizeof(msg));
+ dboid = rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId;
+
+ /*
+ * Store the data in the table's hashtable entry.
+ */
+ dbentry = pgstat_get_db_entry(dboid,
+ PGSTAT_TABLE_WRITE | PGSTAT_TABLE_CREATE,
+ NULL);
+
+ table = dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
+ tabentry = pgstat_get_tab_entry(table, RelationGetRelid(rel), true);
+
+ tabentry->n_live_tuples = livetuples;
+ tabentry->n_dead_tuples = deadtuples;
+
+ /*
+ * If commanded, reset changes_since_analyze to zero. This forgets any
+ * changes that were committed while the ANALYZE was in progress, but we
+ * have no good way to estimate how many of those there were.
+ */
+ if (resetcounter)
+ tabentry->changes_since_analyze = 0;
+
+ if (IsAutoVacuumWorkerProcess())
+ {
+ tabentry->autovac_analyze_timestamp = GetCurrentTimestamp();
+ tabentry->autovac_analyze_count++;
+ }
+ else
+ {
+ tabentry->analyze_timestamp = GetCurrentTimestamp();
+ tabentry->analyze_count++;
+ }
+ dshash_release_lock(table, tabentry);
+ dshash_detach(table);
+ dshash_release_lock(db_stats, dbentry);
}
/* --------
@@ -1483,15 +1321,67 @@ pgstat_report_analyze(Relation rel,
void
pgstat_report_recovery_conflict(int reason)
{
- PgStat_MsgRecoveryConflict msg;
+ static int pending_conflict_tablespace = 0;
+ static int pending_conflict_lock = 0;
+ static int pending_conflict_snapshot = 0;
+ static int pending_conflict_bufferpin = 0;
+ static int pending_conflict_startup_deadlock = 0;
+ PgStat_StatDBEntry *dbentry;
+ pg_stat_table_result_status status;
- if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
+ if (db_stats == NULL || !pgstat_track_counts)
return;
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RECOVERYCONFLICT);
- msg.m_databaseid = MyDatabaseId;
- msg.m_reason = reason;
- pgstat_send(&msg, sizeof(msg));
+ switch (reason)
+ {
+ case PROCSIG_RECOVERY_CONFLICT_DATABASE:
+
+ /*
+ * Since we drop the information about the database as soon as it
+ * replicates, there is no point in counting these conflicts.
+ */
+ break;
+ case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
+ pending_conflict_tablespace++;
+ break;
+ case PROCSIG_RECOVERY_CONFLICT_LOCK:
+ pending_conflict_lock++;
+ break;
+ case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
+ pending_conflict_snapshot++;
+ break;
+ case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
+ pending_conflict_bufferpin++;
+ break;
+ case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
+ pending_conflict_startup_deadlock++;
+ break;
+ }
+ pgstat_pending_recoveryconflict = true;
+
+ dbentry = pgstat_get_db_entry(MyDatabaseId,
+ PGSTAT_TABLE_WRITE | PGSTAT_TABLE_CREATE |
+ PGSTAT_TABLE_NOWAIT,
+ &status);
+
+ if (status == PGSTAT_TABLE_LOCK_FAILED)
+ return;
+
+ dbentry->n_conflict_tablespace += pending_conflict_tablespace;
+ dbentry->n_conflict_lock += pending_conflict_lock;
+ dbentry->n_conflict_snapshot += pending_conflict_snapshot;
+ dbentry->n_conflict_bufferpin += pending_conflict_bufferpin;
+ dbentry->n_conflict_startup_deadlock += pending_conflict_startup_deadlock;
+
+ pending_conflict_tablespace = 0;
+ pending_conflict_lock = 0;
+ pending_conflict_snapshot = 0;
+ pending_conflict_bufferpin = 0;
+ pending_conflict_startup_deadlock = 0;
+
+ dshash_release_lock(db_stats, dbentry);
+
+ pgstat_pending_recoveryconflict = false;
}
/* --------
@@ -1501,16 +1391,31 @@ pgstat_report_recovery_conflict(int reason)
* --------
*/
void
-pgstat_report_deadlock(void)
+pgstat_report_deadlock(bool pending)
{
- PgStat_MsgDeadlock msg;
+ static int pending_deadlocks = 0;
+ PgStat_StatDBEntry *dbentry;
+ pg_stat_table_result_status status;
- if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
+ if (db_stats == NULL || !pgstat_track_counts)
return;
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DEADLOCK);
- msg.m_databaseid = MyDatabaseId;
- pgstat_send(&msg, sizeof(msg));
+ pending_deadlocks++;
+ pgstat_pending_deadlock = true;
+
+ dbentry = pgstat_get_db_entry(MyDatabaseId,
+ PGSTAT_TABLE_WRITE | PGSTAT_TABLE_CREATE |
+ PGSTAT_TABLE_NOWAIT,
+ &status);
+
+ if (status == PGSTAT_TABLE_LOCK_FAILED)
+ return;
+
+ dbentry->n_deadlocks += pending_deadlocks;
+ pending_deadlocks = 0;
+ pgstat_pending_deadlock = false;
+
+ dshash_release_lock(db_stats, dbentry);
}
/* --------
@@ -1522,34 +1427,36 @@ pgstat_report_deadlock(void)
void
pgstat_report_tempfile(size_t filesize)
{
- PgStat_MsgTempFile msg;
+ static size_t pending_filesize = 0;
+ static size_t pending_files = 0;
+ PgStat_StatDBEntry *dbentry;
+ pg_stat_table_result_status status;
- if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
+ if (filesize > 0) /* Is't there a case where filesize is really 0? */
+ {
+ pending_filesize += filesize; /* needs check overflow */
+ pending_files++;
+ }
+ pgstat_pending_tempfile = true;
+
+ if (db_stats == NULL || !pgstat_track_counts)
return;
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TEMPFILE);
- msg.m_databaseid = MyDatabaseId;
- msg.m_filesize = filesize;
- pgstat_send(&msg, sizeof(msg));
-}
+ dbentry = pgstat_get_db_entry(MyDatabaseId,
+ PGSTAT_TABLE_WRITE | PGSTAT_TABLE_CREATE |
+ PGSTAT_TABLE_NOWAIT,
+ &status);
-
-/* ----------
- * pgstat_ping() -
- *
- * Send some junk data to the collector to increase traffic.
- * ----------
- */
-void
-pgstat_ping(void)
-{
- PgStat_MsgDummy msg;
-
- if (pgStatSock == PGINVALID_SOCKET)
+ if (status == PGSTAT_TABLE_LOCK_FAILED)
return;
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DUMMY);
- pgstat_send(&msg, sizeof(msg));
+ dbentry->n_temp_bytes += pending_filesize;
+ dbentry->n_temp_files += pending_files;
+ pending_filesize = 0;
+ pending_files = 0;
+ pgstat_pending_tempfile = false;
+
+ dshash_release_lock(db_stats, dbentry);
}
@@ -1670,7 +1577,7 @@ pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize)
INSTR_TIME_ADD(fs->f_self_time, f_self);
/* indicate that we have something to send */
- have_function_stats = true;
+ pgstat_pending_funcstats = true;
}
@@ -1691,6 +1598,7 @@ pgstat_initstats(Relation rel)
{
Oid rel_id = rel->rd_id;
char relkind = rel->rd_rel->relkind;
+ MemoryContext oldcontext;
/* We only count stats for things that have storage */
if (!(relkind == RELKIND_RELATION ||
@@ -1703,7 +1611,18 @@ pgstat_initstats(Relation rel)
return;
}
- if (pgStatSock == PGINVALID_SOCKET || !pgstat_track_counts)
+ /* Attached shared memory lives for the process lifetime */
+ if (!IsUnderPostmaster)
+ return;
+
+ /* Attached shared memory lives for the process lifetime */
+ oldcontext = MemoryContextSwitchTo(TopMemoryContext);
+ while (!pgstat_attach_shared_stats())
+ sleep(1);
+
+ MemoryContextSwitchTo(oldcontext);
+
+ if (db_stats == NULL || !pgstat_track_counts)
{
/* We're not counting at all */
rel->pgstat_info = NULL;
@@ -2426,7 +2345,7 @@ pgstat_fetch_stat_funcentry(Oid func_id)
PgStat_StatFuncEntry *funcentry = NULL;
/* Lookup our database, then find the requested function */
- dbentry = pgstat_get_db_entry(MyDatabaseId, false);
+ dbentry = pgstat_get_db_entry(MyDatabaseId, PGSTAT_TABLE_READ, NULL);
if (dbentry == NULL)
return NULL;
@@ -2434,6 +2353,7 @@ pgstat_fetch_stat_funcentry(Oid func_id)
if (funcentry == NULL)
return NULL;
+ dshash_release_lock(db_stats, dbentry);
return funcentry;
}
@@ -2721,7 +2641,7 @@ pgstat_initialize(void)
}
/* Set up a process-exit hook to clean up */
- on_shmem_exit(pgstat_beshutdown_hook, 0);
+ before_shmem_exit(pgstat_beshutdown_hook, 0);
}
/* ----------
@@ -4105,49 +4025,6 @@ pgstat_get_backend_desc(BackendType backendType)
* ------------------------------------------------------------
*/
-
-/* ----------
- * pgstat_setheader() -
- *
- * Set common header fields in a statistics message
- * ----------
- */
-static void
-pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
-{
- hdr->m_type = mtype;
-}
-
-
-/* ----------
- * pgstat_send() -
- *
- * Send out one statistics message to the collector
- * ----------
- */
-static void
-pgstat_send(void *msg, int len)
-{
- int rc;
-
- if (pgStatSock == PGINVALID_SOCKET)
- return;
-
- ((PgStat_MsgHdr *) msg)->m_size = len;
-
- /* We'll retry after EINTR, but ignore all other failures */
- do
- {
- rc = send(pgStatSock, msg, len, 0);
- } while (rc < 0 && errno == EINTR);
-
-#ifdef USE_ASSERT_CHECKING
- /* In debug builds, log send failures ... */
- if (rc < 0)
- elog(LOG, "could not send to statistics collector: %m");
-#endif
-}
-
/* ----------
* pgstat_send_archiver() -
*
@@ -4158,16 +4035,22 @@ pgstat_send(void *msg, int len)
void
pgstat_send_archiver(const char *xlog, bool failed)
{
- PgStat_MsgArchiver msg;
-
- /*
- * Prepare and send the message
- */
- pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_ARCHIVER);
- msg.m_failed = failed;
- StrNCpy(msg.m_xlog, xlog, sizeof(msg.m_xlog));
- msg.m_timestamp = GetCurrentTimestamp();
- pgstat_send(&msg, sizeof(msg));
+ if (failed)
+ {
+ /* Failed archival attempt */
+ ++shared_archiverStats->failed_count;
+ memcpy(shared_archiverStats->last_failed_wal, xlog,
+ sizeof(shared_archiverStats->last_failed_wal));
+ shared_archiverStats->last_failed_timestamp = GetCurrentTimestamp();
+ }
+ else
+ {
+ /* Successful archival operation */
+ ++shared_archiverStats->archived_count;
+ memcpy(shared_archiverStats->last_archived_wal, xlog,
+ sizeof(shared_archiverStats->last_archived_wal));
+ shared_archiverStats->last_archived_timestamp = GetCurrentTimestamp();
+ }
}
/* ----------
@@ -4180,21 +4063,36 @@ void
pgstat_send_bgwriter(void)
{
/* We assume this initializes to zeroes */
- static const PgStat_MsgBgWriter all_zeroes;
+ static const PgStat_BgWriter all_zeroes;
+
+ PgStat_BgWriter *s = &BgWriterStats;
+ MemoryContext oldcontext;
/*
* This function can be called even if nothing at all has happened. In
* this case, avoid sending a completely empty message to the stats
* collector.
*/
- if (memcmp(&BgWriterStats, &all_zeroes, sizeof(PgStat_MsgBgWriter)) == 0)
+ if (memcmp(&BgWriterStats, &all_zeroes, sizeof(PgStat_BgWriter)) == 0)
return;
- /*
- * Prepare and send the message
- */
- pgstat_setheader(&BgWriterStats.m_hdr, PGSTAT_MTYPE_BGWRITER);
- pgstat_send(&BgWriterStats, sizeof(BgWriterStats));
+ /* Attached shared memory lives for the process lifetime */
+ oldcontext = MemoryContextSwitchTo(TopMemoryContext);
+ while (!pgstat_attach_shared_stats())
+ sleep(1);
+
+ MemoryContextSwitchTo(oldcontext);
+
+ shared_globalStats->timed_checkpoints += s->timed_checkpoints;
+ shared_globalStats->requested_checkpoints += s->requested_checkpoints;
+ shared_globalStats->checkpoint_write_time += s->checkpoint_write_time;
+ shared_globalStats->checkpoint_sync_time += s->checkpoint_sync_time;
+ shared_globalStats->buf_written_checkpoints += s->buf_written_checkpoints;
+ shared_globalStats->buf_written_clean += s->buf_written_clean;
+ shared_globalStats->maxwritten_clean += s->maxwritten_clean;
+ shared_globalStats->buf_written_backend += s->buf_written_backend;
+ shared_globalStats->buf_fsync_backend += s->buf_fsync_backend;
+ shared_globalStats->buf_alloc += s->buf_alloc;
/*
* Clear out the statistics buffer, so it can be re-used.
@@ -4215,8 +4113,6 @@ pgstat_send_bgwriter(void)
void
PgstatCollectorMain(void)
{
- int len;
- PgStat_Msg msg;
int wr;
/*
@@ -4246,20 +4142,6 @@ PgstatCollectorMain(void)
pgStatRunningInCollector = true;
pgstat_read_statsfiles();
- /*
- * Loop to process messages until we get SIGQUIT or detect ungraceful
- * death of our parent postmaster.
- *
- * For performance reasons, we don't want to do ResetLatch/WaitLatch after
- * every message; instead, do that only after a recv() fails to obtain a
- * message. (This effectively means that if backends are sending us stuff
- * like mad, we won't notice postmaster death until things slack off a
- * bit; which seems fine.) To do that, we have an inner loop that
- * iterates as long as recv() succeeds. We do recognize got_SIGHUP inside
- * the inner loop, which means that such interrupts will get serviced but
- * the latch won't get cleared until next time there is a break in the
- * action.
- */
for (;;)
{
/* Clear any already-pending wakeups */
@@ -4272,164 +4154,16 @@ PgstatCollectorMain(void)
break;
/*
- * Inner loop iterates as long as we keep getting messages, or until
- * need_exit becomes set.
+ * Reload configuration if we got SIGHUP from the postmaster.
*/
- while (!got_SIGTERM)
+ if (got_SIGHUP)
{
- /*
- * Reload configuration if we got SIGHUP from the postmaster.
- */
- if (got_SIGHUP)
- {
- got_SIGHUP = false;
- ProcessConfigFile(PGC_SIGHUP);
- }
-
- /*
- * Try to receive and process a message. This will not block,
- * since the socket is set to non-blocking mode.
- *
- * XXX On Windows, we have to force pgwin32_recv to cooperate,
- * despite the previous use of pg_set_noblock() on the socket.
- * This is extremely broken and should be fixed someday.
- */
-#ifdef WIN32
- pgwin32_noblock = 1;
-#endif
-
- len = recv(pgStatSock, (char *) &msg,
- sizeof(PgStat_Msg), 0);
-
-#ifdef WIN32
- pgwin32_noblock = 0;
-#endif
-
- if (len < 0)
- {
- if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
- break; /* out of inner loop */
- ereport(ERROR,
- (errcode_for_socket_access(),
- errmsg("could not read statistics message: %m")));
- }
-
- /*
- * We ignore messages that are smaller than our common header
- */
- if (len < sizeof(PgStat_MsgHdr))
- continue;
-
- /*
- * The received length must match the length in the header
- */
- if (msg.msg_hdr.m_size != len)
- continue;
-
- /*
- * O.K. - we accept this message. Process it.
- */
- switch (msg.msg_hdr.m_type)
- {
- case PGSTAT_MTYPE_DUMMY:
- break;
-
- case PGSTAT_MTYPE_TABSTAT:
- pgstat_recv_tabstat((PgStat_MsgTabstat *) &msg, len);
- break;
-
- case PGSTAT_MTYPE_TABPURGE:
- pgstat_recv_tabpurge((PgStat_MsgTabpurge *) &msg, len);
- break;
-
- case PGSTAT_MTYPE_DROPDB:
- pgstat_recv_dropdb((PgStat_MsgDropdb *) &msg, len);
- break;
-
- case PGSTAT_MTYPE_RESETCOUNTER:
- pgstat_recv_resetcounter((PgStat_MsgResetcounter *) &msg,
- len);
- break;
-
- case PGSTAT_MTYPE_RESETSHAREDCOUNTER:
- pgstat_recv_resetsharedcounter(
- (PgStat_MsgResetsharedcounter *) &msg,
- len);
- break;
-
- case PGSTAT_MTYPE_RESETSINGLECOUNTER:
- pgstat_recv_resetsinglecounter(
- (PgStat_MsgResetsinglecounter *) &msg,
- len);
- break;
-
- case PGSTAT_MTYPE_AUTOVAC_START:
- pgstat_recv_autovac((PgStat_MsgAutovacStart *) &msg, len);
- break;
-
- case PGSTAT_MTYPE_VACUUM:
- pgstat_recv_vacuum((PgStat_MsgVacuum *) &msg, len);
- break;
-
- case PGSTAT_MTYPE_ANALYZE:
- pgstat_recv_analyze((PgStat_MsgAnalyze *) &msg, len);
- break;
-
- case PGSTAT_MTYPE_ARCHIVER:
- pgstat_recv_archiver((PgStat_MsgArchiver *) &msg, len);
- break;
-
- case PGSTAT_MTYPE_BGWRITER:
- pgstat_recv_bgwriter((PgStat_MsgBgWriter *) &msg, len);
- break;
-
- case PGSTAT_MTYPE_FUNCSTAT:
- pgstat_recv_funcstat((PgStat_MsgFuncstat *) &msg, len);
- break;
-
- case PGSTAT_MTYPE_FUNCPURGE:
- pgstat_recv_funcpurge((PgStat_MsgFuncpurge *) &msg, len);
- break;
-
- case PGSTAT_MTYPE_RECOVERYCONFLICT:
- pgstat_recv_recoveryconflict((PgStat_MsgRecoveryConflict *) &msg, len);
- break;
-
- case PGSTAT_MTYPE_DEADLOCK:
- pgstat_recv_deadlock((PgStat_MsgDeadlock *) &msg, len);
- break;
-
- case PGSTAT_MTYPE_TEMPFILE:
- pgstat_recv_tempfile((PgStat_MsgTempFile *) &msg, len);
- break;
-
- default:
- break;
- }
- } /* end of inner message-processing loop */
-
- /* Sleep until there's something to do */
-#ifndef WIN32
- wr = WaitLatchOrSocket(MyLatch,
- WL_LATCH_SET | WL_POSTMASTER_DEATH | WL_SOCKET_READABLE,
- pgStatSock, -1L,
- WAIT_EVENT_PGSTAT_MAIN);
-#else
-
- /*
- * Windows, at least in its Windows Server 2003 R2 incarnation,
- * sometimes loses FD_READ events. Waking up and retrying the recv()
- * fixes that, so don't sleep indefinitely. This is a crock of the
- * first water, but until somebody wants to debug exactly what's
- * happening there, this is the best we can do. The two-second
- * timeout matches our pre-9.2 behavior.
- */
- wr = WaitLatchOrSocket(MyLatch,
- WL_LATCH_SET | WL_POSTMASTER_DEATH | WL_SOCKET_READABLE | WL_TIMEOUT,
- pgStatSock,
- 2 * 1000L /* msec */ ,
- WAIT_EVENT_PGSTAT_MAIN);
-#endif
+ got_SIGHUP = false;
+ ProcessConfigFile(PGC_SIGHUP);
+ }
+
+ wr = WaitLatch(MyLatch, WL_LATCH_SET | WL_POSTMASTER_DEATH, -1L,
+ WAIT_EVENT_PGSTAT_MAIN);
/*
* Emergency bailout if postmaster has died. This is to avoid the
@@ -4437,8 +4171,8 @@ PgstatCollectorMain(void)
*/
if (wr & WL_POSTMASTER_DEATH)
break;
- } /* end of outer loop */
-
+ }
+
/*
* Save the final stats to reuse at next startup.
*/
@@ -4552,29 +4286,62 @@ reset_dbentry_counters(PgStat_StatDBEntry *dbentry)
* Else, return NULL.
*/
static PgStat_StatDBEntry *
-pgstat_get_db_entry(Oid databaseid, bool create)
+pgstat_get_db_entry(Oid databaseid, int op, pg_stat_table_result_status *status)
{
PgStat_StatDBEntry *result;
- bool found;
+ bool nowait = ((op & PGSTAT_TABLE_NOWAIT) != 0);
+ bool lock_acquired = true;
+ bool found = true;
+ MemoryContext oldcontext;
- Assert(pgStatRunningInCollector);
+ /* XXXXXXX */
+ oldcontext = MemoryContextSwitchTo(TopMemoryContext);
+ if (!pgstat_attach_shared_stats())
+ {
+ MemoryContextSwitchTo(oldcontext);
+ return false;
+ }
+ MemoryContextSwitchTo(oldcontext);
/* Lookup or create the hash table entry for this database */
- if (create)
+ if (op & PGSTAT_TABLE_CREATE)
+ {
result = (PgStat_StatDBEntry *)
- dshash_find_or_insert(db_stats, &databaseid, &found);
+ dshash_find_or_insert_extended(db_stats, &databaseid,
+ &found, nowait);
+ if (result == NULL)
+ lock_acquired = false;
+ else if (!found)
+ {
+ /*
+ * If not found, initialize the new one. This creates empty hash
+ * tables for tables and functions, too.
+ */
+ reset_dbentry_counters(result);
+ }
+ }
else
- result = (PgStat_StatDBEntry *) dshash_find(db_stats, &databaseid, true);
+ {
+ result = (PgStat_StatDBEntry *)
+ dshash_find_extended(db_stats, &databaseid,
+ &lock_acquired, true, nowait);
+ if (result == NULL)
+ found = false;
+ }
- if (!create)
- return result;
-
- /*
- * If not found, initialize the new one. This creates empty hash tables
- * for tables and functions, too.
- */
- if (!found)
- reset_dbentry_counters(result);
+ /* Set return status if requested */
+ if (status)
+ {
+ if (!lock_acquired)
+ {
+ Assert(nowait);
+ *status = PGSTAT_TABLE_LOCK_FAILED;
+ }
+ else if (!found)
+ *status = PGSTAT_TABLE_NOT_FOUND;
+ else
+ *status = PGSTAT_TABLE_FOUND;
+ }
return result;
}
@@ -5646,108 +5413,124 @@ pgstat_clear_snapshot(void)
* Count what the backend has done.
* ----------
*/
-static void
-pgstat_recv_tabstat(PgStat_MsgTabstat *msg, int len)
+static dshash_table *
+pgstat_update_dbentry(Oid dboid)
{
- dshash_table *tabhash;
PgStat_StatDBEntry *dbentry;
- PgStat_StatTabEntry *tabentry;
- int i;
- bool found;
+ pg_stat_table_result_status status;
+ dshash_table *tabhash;
- dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
-
- /*
- * Update database-wide stats.
- */
- dbentry->n_xact_commit += (PgStat_Counter) (msg->m_xact_commit);
- dbentry->n_xact_rollback += (PgStat_Counter) (msg->m_xact_rollback);
- dbentry->n_block_read_time += msg->m_block_read_time;
- dbentry->n_block_write_time += msg->m_block_write_time;
+ dbentry = pgstat_get_db_entry(dboid,
+ PGSTAT_TABLE_WRITE
+ | PGSTAT_TABLE_CREATE
+ | PGSTAT_TABLE_NOWAIT,
+ &status);
+
+ /* return if lock failed */
+ if (status == PGSTAT_TABLE_LOCK_FAILED)
+ return NULL;
tabhash = dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
- /*
- * Process all table entries in the message.
- */
- for (i = 0; i < msg->m_nentries; i++)
+
+ if (OidIsValid(dboid))
{
- PgStat_TableEntry *tabmsg = &(msg->m_entry[i]);
-
- tabentry = (PgStat_StatTabEntry *)
- dshash_find_or_insert(tabhash, (void *) &(tabmsg->t_id), &found);
-
- if (!found)
- {
- /*
- * If it's a new table entry, initialize counters to the values we
- * just got.
- */
- tabentry->numscans = tabmsg->t_counts.t_numscans;
- tabentry->tuples_returned = tabmsg->t_counts.t_tuples_returned;
- tabentry->tuples_fetched = tabmsg->t_counts.t_tuples_fetched;
- tabentry->tuples_inserted = tabmsg->t_counts.t_tuples_inserted;
- tabentry->tuples_updated = tabmsg->t_counts.t_tuples_updated;
- tabentry->tuples_deleted = tabmsg->t_counts.t_tuples_deleted;
- tabentry->tuples_hot_updated = tabmsg->t_counts.t_tuples_hot_updated;
- tabentry->n_live_tuples = tabmsg->t_counts.t_delta_live_tuples;
- tabentry->n_dead_tuples = tabmsg->t_counts.t_delta_dead_tuples;
- tabentry->changes_since_analyze = tabmsg->t_counts.t_changed_tuples;
- tabentry->blocks_fetched = tabmsg->t_counts.t_blocks_fetched;
- tabentry->blocks_hit = tabmsg->t_counts.t_blocks_hit;
-
- tabentry->vacuum_timestamp = 0;
- tabentry->vacuum_count = 0;
- tabentry->autovac_vacuum_timestamp = 0;
- tabentry->autovac_vacuum_count = 0;
- tabentry->analyze_timestamp = 0;
- tabentry->analyze_count = 0;
- tabentry->autovac_analyze_timestamp = 0;
- tabentry->autovac_analyze_count = 0;
- }
- else
- {
- /*
- * Otherwise add the values to the existing entry.
- */
- tabentry->numscans += tabmsg->t_counts.t_numscans;
- tabentry->tuples_returned += tabmsg->t_counts.t_tuples_returned;
- tabentry->tuples_fetched += tabmsg->t_counts.t_tuples_fetched;
- tabentry->tuples_inserted += tabmsg->t_counts.t_tuples_inserted;
- tabentry->tuples_updated += tabmsg->t_counts.t_tuples_updated;
- tabentry->tuples_deleted += tabmsg->t_counts.t_tuples_deleted;
- tabentry->tuples_hot_updated += tabmsg->t_counts.t_tuples_hot_updated;
- /* If table was truncated, first reset the live/dead counters */
- if (tabmsg->t_counts.t_truncated)
- {
- tabentry->n_live_tuples = 0;
- tabentry->n_dead_tuples = 0;
- }
- tabentry->n_live_tuples += tabmsg->t_counts.t_delta_live_tuples;
- tabentry->n_dead_tuples += tabmsg->t_counts.t_delta_dead_tuples;
- tabentry->changes_since_analyze += tabmsg->t_counts.t_changed_tuples;
- tabentry->blocks_fetched += tabmsg->t_counts.t_blocks_fetched;
- tabentry->blocks_hit += tabmsg->t_counts.t_blocks_hit;
- }
-
- /* Clamp n_live_tuples in case of negative delta_live_tuples */
- tabentry->n_live_tuples = Max(tabentry->n_live_tuples, 0);
- /* Likewise for n_dead_tuples */
- tabentry->n_dead_tuples = Max(tabentry->n_dead_tuples, 0);
- dshash_release_lock(tabhash, tabentry);
-
/*
- * Add per-table stats to the per-database entry, too.
+ * Update database-wide stats.
*/
- dbentry->n_tuples_returned += tabmsg->t_counts.t_tuples_returned;
- dbentry->n_tuples_fetched += tabmsg->t_counts.t_tuples_fetched;
- dbentry->n_tuples_inserted += tabmsg->t_counts.t_tuples_inserted;
- dbentry->n_tuples_updated += tabmsg->t_counts.t_tuples_updated;
- dbentry->n_tuples_deleted += tabmsg->t_counts.t_tuples_deleted;
- dbentry->n_blocks_fetched += tabmsg->t_counts.t_blocks_fetched;
- dbentry->n_blocks_hit += tabmsg->t_counts.t_blocks_hit;
+ dbentry->n_xact_commit += pgStatXactCommit;
+ dbentry->n_xact_rollback += pgStatXactRollback;
+ dbentry->n_block_read_time += pgStatBlockReadTime;
+ dbentry->n_block_write_time += pgStatBlockWriteTime;
}
+ pgStatXactCommit = 0;
+ pgStatXactRollback = 0;
+ pgStatBlockReadTime = 0;
+ pgStatBlockWriteTime = 0;
+
dshash_release_lock(db_stats, dbentry);
+
+ return tabhash;
+}
+
+static bool
+pgstat_update_tabentry(dshash_table *tabhash, PgStat_TableStatus *stat)
+{
+ PgStat_StatTabEntry *tabentry;
+ bool found;
+
+ if (tabhash == NULL)
+ return false;
+
+ tabentry = (PgStat_StatTabEntry *)
+ dshash_find_or_insert_extended(tabhash, (void *) &(stat->t_id),
+ &found, true);
+
+ /* failed to acquire lock */
+ if (tabentry == NULL)
+ return false;
+
+ if (!found)
+ {
+ /*
+ * If it's a new table entry, initialize counters to the values we
+ * just got.
+ */
+ tabentry->numscans = stat->t_counts.t_numscans;
+ tabentry->tuples_returned = stat->t_counts.t_tuples_returned;
+ tabentry->tuples_fetched = stat->t_counts.t_tuples_fetched;
+ tabentry->tuples_inserted = stat->t_counts.t_tuples_inserted;
+ tabentry->tuples_updated = stat->t_counts.t_tuples_updated;
+ tabentry->tuples_deleted = stat->t_counts.t_tuples_deleted;
+ tabentry->tuples_hot_updated = stat->t_counts.t_tuples_hot_updated;
+ tabentry->n_live_tuples = stat->t_counts.t_delta_live_tuples;
+ tabentry->n_dead_tuples = stat->t_counts.t_delta_dead_tuples;
+ tabentry->changes_since_analyze = stat->t_counts.t_changed_tuples;
+ tabentry->blocks_fetched = stat->t_counts.t_blocks_fetched;
+ tabentry->blocks_hit = stat->t_counts.t_blocks_hit;
+
+ tabentry->vacuum_timestamp = 0;
+ tabentry->vacuum_count = 0;
+ tabentry->autovac_vacuum_timestamp = 0;
+ tabentry->autovac_vacuum_count = 0;
+ tabentry->analyze_timestamp = 0;
+ tabentry->analyze_count = 0;
+ tabentry->autovac_analyze_timestamp = 0;
+ tabentry->autovac_analyze_count = 0;
+ }
+ else
+ {
+ /*
+ * Otherwise add the values to the existing entry.
+ */
+ tabentry->numscans += stat->t_counts.t_numscans;
+ tabentry->tuples_returned += stat->t_counts.t_tuples_returned;
+ tabentry->tuples_fetched += stat->t_counts.t_tuples_fetched;
+ tabentry->tuples_inserted += stat->t_counts.t_tuples_inserted;
+ tabentry->tuples_updated += stat->t_counts.t_tuples_updated;
+ tabentry->tuples_deleted += stat->t_counts.t_tuples_deleted;
+ tabentry->tuples_hot_updated += stat->t_counts.t_tuples_hot_updated;
+ /* If table was truncated, first reset the live/dead counters */
+ if (stat->t_counts.t_truncated)
+ {
+ tabentry->n_live_tuples = 0;
+ tabentry->n_dead_tuples = 0;
+ }
+ tabentry->n_live_tuples += stat->t_counts.t_delta_live_tuples;
+ tabentry->n_dead_tuples += stat->t_counts.t_delta_dead_tuples;
+ tabentry->changes_since_analyze += stat->t_counts.t_changed_tuples;
+ tabentry->blocks_fetched += stat->t_counts.t_blocks_fetched;
+ tabentry->blocks_hit += stat->t_counts.t_blocks_hit;
+ }
+
+ /* Clamp n_live_tuples in case of negative delta_live_tuples */
+ tabentry->n_live_tuples = Max(tabentry->n_live_tuples, 0);
+ /* Likewise for n_dead_tuples */
+ tabentry->n_dead_tuples = Max(tabentry->n_dead_tuples, 0);
+
+ dshash_release_lock(tabhash, tabentry);
+
+ return true;
}
@@ -5757,14 +5540,15 @@ pgstat_recv_tabstat(PgStat_MsgTabstat *msg, int len)
* Arrange for dead table removal.
* ----------
*/
-static void
-pgstat_recv_tabpurge(PgStat_MsgTabpurge *msg, int len)
+static bool
+pgstat_tabpurge(Oid dboid, Oid taboid)
{
dshash_table *tbl;
PgStat_StatDBEntry *dbentry;
- int i;
- dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
+ /* wait for lock */
+ dbentry = pgstat_get_db_entry(dboid, PGSTAT_TABLE_WRITE, NULL);
+
/*
* No need to purge if we don't even know the database.
*/
@@ -5772,459 +5556,67 @@ pgstat_recv_tabpurge(PgStat_MsgTabpurge *msg, int len)
{
if (dbentry)
dshash_release_lock(db_stats, dbentry);
- return;
+ return true;
}
tbl = dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
- /*
- * Process all table entries in the message.
- */
- for (i = 0; i < msg->m_nentries; i++)
- {
- /* Remove from hashtable if present; we don't care if it's not. */
- (void) dshash_delete_key(tbl, (void *) &(msg->m_tableid[i]));
- }
+
+ /* Remove from hashtable if present; we don't care if it's not. */
+ (void) dshash_delete_key(tbl, (void *) &taboid);
dshash_release_lock(db_stats, dbentry);
+ return true;
}
/* ----------
- * pgstat_recv_dropdb() -
- *
- * Arrange for dead database removal
- * ----------
- */
-static void
-pgstat_recv_dropdb(PgStat_MsgDropdb *msg, int len)
-{
- Oid dbid = msg->m_databaseid;
- PgStat_StatDBEntry *dbentry;
-
- /*
- * Lookup the database in the hashtable.
- */
- dbentry = pgstat_get_db_entry(dbid, false);
-
- /*
- * If found, remove it (along with the db statfile).
- */
- if (dbentry)
- {
- if (dbentry->tables != DSM_HANDLE_INVALID)
- {
- dshash_table *tbl =
- dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
- dshash_destroy(tbl);
- }
- if (dbentry->functions != DSM_HANDLE_INVALID)
- {
- dshash_table *tbl =
- dshash_attach(area, &dsh_funcparams, dbentry->functions, 0);
- dshash_destroy(tbl);
- }
-
- dshash_delete_entry(db_stats, (void *)dbentry);
- }
-}
-
-
-/* ----------
- * pgstat_recv_resetcounter() -
- *
- * Reset the statistics for the specified database.
- * ----------
- */
-static void
-pgstat_recv_resetcounter(PgStat_MsgResetcounter *msg, int len)
-{
- PgStat_StatDBEntry *dbentry;
-
- /*
- * Lookup the database in the hashtable. Nothing to do if not there.
- */
- dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
-
- if (!dbentry)
- return;
-
- /*
- * We simply throw away all the database's table entries by recreating a
- * new hash table for them.
- */
- if (dbentry->tables != DSM_HANDLE_INVALID)
- {
- dshash_table *t =
- dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
- dshash_destroy(t);
- dbentry->tables = DSM_HANDLE_INVALID;
- }
- if (dbentry->functions != DSM_HANDLE_INVALID)
- {
- dshash_table *t =
- dshash_attach(area, &dsh_funcparams, dbentry->functions, 0);
- dshash_destroy(t);
- dbentry->functions = DSM_HANDLE_INVALID;
- }
-
- /*
- * Reset database-level stats, too. This creates empty hash tables for
- * tables and functions.
- */
- reset_dbentry_counters(dbentry);
-
- dshash_release_lock(db_stats, dbentry);
-}
-
-/* ----------
- * pgstat_recv_resetshared() -
- *
- * Reset some shared statistics of the cluster.
- * ----------
- */
-static void
-pgstat_recv_resetsharedcounter(PgStat_MsgResetsharedcounter *msg, int len)
-{
- if (msg->m_resettarget == RESET_BGWRITER)
- {
- /* Reset the global background writer statistics for the cluster. */
- memset(&shared_globalStats, 0, sizeof(shared_globalStats));
- shared_globalStats->stat_reset_timestamp = GetCurrentTimestamp();
- }
- else if (msg->m_resettarget == RESET_ARCHIVER)
- {
- /* Reset the archiver statistics for the cluster. */
- memset(&shared_archiverStats, 0, sizeof(shared_archiverStats));
- shared_archiverStats->stat_reset_timestamp = GetCurrentTimestamp();
- }
-
- /*
- * Presumably the sender of this message validated the target, don't
- * complain here if it's not valid
- */
-}
-
-/* ----------
- * pgstat_recv_resetsinglecounter() -
- *
- * Reset a statistics for a single object
- * ----------
- */
-static void
-pgstat_recv_resetsinglecounter(PgStat_MsgResetsinglecounter *msg, int len)
-{
- PgStat_StatDBEntry *dbentry;
-
- dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
-
- if (!dbentry)
- return;
-
- /* Set the reset timestamp for the whole database */
- dbentry->stat_reset_timestamp = GetCurrentTimestamp();
-
- /* Remove object if it exists, ignore it if not */
- if (msg->m_resettype == RESET_TABLE)
- {
- dshash_table *t =
- dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
- dshash_delete_key(t, (void *) &(msg->m_objectid));
- }
- else if (msg->m_resettype == RESET_FUNCTION)
- {
- dshash_table *t =
- dshash_attach(area, &dsh_funcparams, dbentry->functions, 0);
- dshash_delete_key(t, (void *) &(msg->m_objectid));
- }
-
- dshash_release_lock(db_stats, dbentry);
-}
-
-/* ----------
- * pgstat_recv_autovac() -
- *
- * Process an autovacuum signalling message.
- * ----------
- */
-static void
-pgstat_recv_autovac(PgStat_MsgAutovacStart *msg, int len)
-{
- PgStat_StatDBEntry *dbentry;
-
- /*
- * Store the last autovacuum time in the database's hashtable entry.
- */
- dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
-
- dbentry->last_autovac_time = msg->m_start_time;
-
- dshash_release_lock(db_stats, dbentry);
-}
-
-/* ----------
- * pgstat_recv_vacuum() -
- *
- * Process a VACUUM message.
- * ----------
- */
-static void
-pgstat_recv_vacuum(PgStat_MsgVacuum *msg, int len)
-{
- PgStat_StatDBEntry *dbentry;
- PgStat_StatTabEntry *tabentry;
- dshash_table *table;
- /*
- * Store the data in the table's hashtable entry.
- */
- dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
- table = dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
- tabentry = pgstat_get_tab_entry(table, msg->m_tableoid, true);
-
- tabentry->n_live_tuples = msg->m_live_tuples;
- tabentry->n_dead_tuples = msg->m_dead_tuples;
-
- if (msg->m_autovacuum)
- {
- tabentry->autovac_vacuum_timestamp = msg->m_vacuumtime;
- tabentry->autovac_vacuum_count++;
- }
- else
- {
- tabentry->vacuum_timestamp = msg->m_vacuumtime;
- tabentry->vacuum_count++;
- }
- dshash_release_lock(table, tabentry);
- dshash_detach(table);
- dshash_release_lock(db_stats, dbentry);
-}
-
-/* ----------
- * pgstat_recv_analyze() -
- *
- * Process an ANALYZE message.
- * ----------
- */
-static void
-pgstat_recv_analyze(PgStat_MsgAnalyze *msg, int len)
-{
- PgStat_StatDBEntry *dbentry;
- PgStat_StatTabEntry *tabentry;
- dshash_table *table;
-
- /*
- * Store the data in the table's hashtable entry.
- */
- dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
-
- table = dshash_attach(area, &dsh_tblparams, dbentry->tables, 0);
- tabentry = pgstat_get_tab_entry(table, msg->m_tableoid, true);
-
- tabentry->n_live_tuples = msg->m_live_tuples;
- tabentry->n_dead_tuples = msg->m_dead_tuples;
-
- /*
- * If commanded, reset changes_since_analyze to zero. This forgets any
- * changes that were committed while the ANALYZE was in progress, but we
- * have no good way to estimate how many of those there were.
- */
- if (msg->m_resetcounter)
- tabentry->changes_since_analyze = 0;
-
- if (msg->m_autovacuum)
- {
- tabentry->autovac_analyze_timestamp = msg->m_analyzetime;
- tabentry->autovac_analyze_count++;
- }
- else
- {
- tabentry->analyze_timestamp = msg->m_analyzetime;
- tabentry->analyze_count++;
- }
- dshash_release_lock(table, tabentry);
- dshash_detach(table);
- dshash_release_lock(db_stats, dbentry);
-}
-
-
-/* ----------
- * pgstat_recv_archiver() -
- *
- * Process a ARCHIVER message.
- * ----------
- */
-static void
-pgstat_recv_archiver(PgStat_MsgArchiver *msg, int len)
-{
- if (msg->m_failed)
- {
- /* Failed archival attempt */
- ++shared_archiverStats->failed_count;
- memcpy(shared_archiverStats->last_failed_wal, msg->m_xlog,
- sizeof(shared_archiverStats->last_failed_wal));
- shared_archiverStats->last_failed_timestamp = msg->m_timestamp;
- }
- else
- {
- /* Successful archival operation */
- ++shared_archiverStats->archived_count;
- memcpy(shared_archiverStats->last_archived_wal, msg->m_xlog,
- sizeof(shared_archiverStats->last_archived_wal));
- shared_archiverStats->last_archived_timestamp = msg->m_timestamp;
- }
-}
-
-/* ----------
- * pgstat_recv_bgwriter() -
- *
- * Process a BGWRITER message.
- * ----------
- */
-static void
-pgstat_recv_bgwriter(PgStat_MsgBgWriter *msg, int len)
-{
- shared_globalStats->timed_checkpoints += msg->m_timed_checkpoints;
- shared_globalStats->requested_checkpoints += msg->m_requested_checkpoints;
- shared_globalStats->checkpoint_write_time += msg->m_checkpoint_write_time;
- shared_globalStats->checkpoint_sync_time += msg->m_checkpoint_sync_time;
- shared_globalStats->buf_written_checkpoints += msg->m_buf_written_checkpoints;
- shared_globalStats->buf_written_clean += msg->m_buf_written_clean;
- shared_globalStats->maxwritten_clean += msg->m_maxwritten_clean;
- shared_globalStats->buf_written_backend += msg->m_buf_written_backend;
- shared_globalStats->buf_fsync_backend += msg->m_buf_fsync_backend;
- shared_globalStats->buf_alloc += msg->m_buf_alloc;
-}
-
-/* ----------
- * pgstat_recv_recoveryconflict() -
- *
- * Process a RECOVERYCONFLICT message.
- * ----------
- */
-static void
-pgstat_recv_recoveryconflict(PgStat_MsgRecoveryConflict *msg, int len)
-{
- PgStat_StatDBEntry *dbentry;
-
- dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
-
- switch (msg->m_reason)
- {
- case PROCSIG_RECOVERY_CONFLICT_DATABASE:
-
- /*
- * Since we drop the information about the database as soon as it
- * replicates, there is no point in counting these conflicts.
- */
- break;
- case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
- dbentry->n_conflict_tablespace++;
- break;
- case PROCSIG_RECOVERY_CONFLICT_LOCK:
- dbentry->n_conflict_lock++;
- break;
- case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
- dbentry->n_conflict_snapshot++;
- break;
- case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
- dbentry->n_conflict_bufferpin++;
- break;
- case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
- dbentry->n_conflict_startup_deadlock++;
- break;
- }
-
- dshash_release_lock(db_stats, dbentry);
-}
-
-/* ----------
- * pgstat_recv_deadlock() -
- *
- * Process a DEADLOCK message.
- * ----------
- */
-static void
-pgstat_recv_deadlock(PgStat_MsgDeadlock *msg, int len)
-{
- PgStat_StatDBEntry *dbentry;
-
- dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
-
- dbentry->n_deadlocks++;
-
- dshash_release_lock(db_stats, dbentry);
-}
-
-/* ----------
- * pgstat_recv_tempfile() -
- *
- * Process a TEMPFILE message.
- * ----------
- */
-static void
-pgstat_recv_tempfile(PgStat_MsgTempFile *msg, int len)
-{
- PgStat_StatDBEntry *dbentry;
-
- dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
-
- dbentry->n_temp_bytes += msg->m_filesize;
- dbentry->n_temp_files += 1;
-
- dshash_release_lock(db_stats, dbentry);
-}
-
-/* ----------
- * pgstat_recv_funcstat() -
+ * pgstat_funcstat() -
*
* Count what the backend has done.
* ----------
*/
-static void
-pgstat_recv_funcstat(PgStat_MsgFuncstat *msg, int len)
+static bool
+pgstat_update_funcentry(dshash_table *funchash,
+ PgStat_BackendFunctionEntry *stat)
{
- dshash_table *t;
- PgStat_FunctionEntry *funcmsg = &(msg->m_entry[0]);
- PgStat_StatDBEntry *dbentry;
PgStat_StatFuncEntry *funcentry;
- int i;
bool found;
- dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
+ funcentry = (PgStat_StatFuncEntry *)
+ dshash_find_or_insert_extended(funchash, (void *) &(stat->f_id),
+ &found, true);
- t = dshash_attach(area, &dsh_funcparams, dbentry->functions, 0);
- /*
- * Process all function entries in the message.
- */
- for (i = 0; i < msg->m_nentries; i++, funcmsg++)
+ if (funcentry == NULL)
+ return false;
+
+ if (!found)
{
- funcentry = (PgStat_StatFuncEntry *)
- dshash_find_or_insert(t, (void *) &(funcmsg->f_id), &found);
-
- if (!found)
- {
- /*
- * If it's a new function entry, initialize counters to the values
- * we just got.
- */
- funcentry->f_numcalls = funcmsg->f_numcalls;
- funcentry->f_total_time = funcmsg->f_total_time;
- funcentry->f_self_time = funcmsg->f_self_time;
- }
- else
- {
- /*
- * Otherwise add the values to the existing entry.
- */
- funcentry->f_numcalls += funcmsg->f_numcalls;
- funcentry->f_total_time += funcmsg->f_total_time;
- funcentry->f_self_time += funcmsg->f_self_time;
- }
- dshash_release_lock(t, funcentry);
+ /*
+ * If it's a new function entry, initialize counters to the values
+ * we just got.
+ */
+ funcentry->f_numcalls = stat->f_counts.f_numcalls;
+ funcentry->f_total_time =
+ INSTR_TIME_GET_MICROSEC(stat->f_counts.f_total_time);
+ funcentry->f_self_time =
+ INSTR_TIME_GET_MICROSEC(stat->f_counts.f_self_time);
+ }
+ else
+ {
+ /*
+ * Otherwise add the values to the existing entry.
+ */
+ funcentry->f_numcalls += stat->f_counts.f_numcalls;
+ funcentry->f_total_time +=
+ INSTR_TIME_GET_MICROSEC(stat->f_counts.f_total_time);
+ funcentry->f_self_time +=
+ INSTR_TIME_GET_MICROSEC(stat->f_counts.f_self_time);
}
- dshash_detach(t);
- dshash_release_lock(db_stats, dbentry);
+ dshash_release_lock(funchash, funcentry);
+
+ return true;
}
/* ----------
@@ -6233,32 +5625,30 @@ pgstat_recv_funcstat(PgStat_MsgFuncstat *msg, int len)
* Arrange for dead function removal.
* ----------
*/
-static void
-pgstat_recv_funcpurge(PgStat_MsgFuncpurge *msg, int len)
+static bool
+pgstat_funcpurge(Oid dboid, Oid funcoid)
{
dshash_table *t;
PgStat_StatDBEntry *dbentry;
- int i;
- dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
+ /* wait for lock */
+ dbentry = pgstat_get_db_entry(dboid, PGSTAT_TABLE_WRITE, NULL);
/*
* No need to purge if we don't even know the database.
*/
if (!dbentry || dbentry->functions == DSM_HANDLE_INVALID)
- return;
+ return true;
t = dshash_attach(area, &dsh_funcparams, dbentry->functions, 0);
- /*
- * Process all function entries in the message.
- */
- for (i = 0; i < msg->m_nentries; i++)
- {
- /* Remove from hashtable if present; we don't care if it's not. */
- dshash_delete_key(t, (void *) &(msg->m_functionid[i]));
- }
+
+ /* Remove from hashtable if present; we don't care if it's not. */
+ dshash_delete_key(t, (void *) &funcoid);
dshash_detach(t);
+
dshash_release_lock(db_stats, dbentry);
+
+ return true;
}
/*
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 01eabe5706..e794a81c4c 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -1984,7 +1984,7 @@ BufferSync(int flags)
if (SyncOneBuffer(buf_id, false, &wb_context) & BUF_WRITTEN)
{
TRACE_POSTGRESQL_BUFFER_SYNC_WRITTEN(buf_id);
- BgWriterStats.m_buf_written_checkpoints++;
+ BgWriterStats.buf_written_checkpoints++;
num_written++;
}
}
@@ -2092,7 +2092,7 @@ BgBufferSync(WritebackContext *wb_context)
strategy_buf_id = StrategySyncStart(&strategy_passes, &recent_alloc);
/* Report buffer alloc counts to pgstat */
- BgWriterStats.m_buf_alloc += recent_alloc;
+ BgWriterStats.buf_alloc += recent_alloc;
/*
* If we're not running the LRU scan, just stop after doing the stats
@@ -2282,7 +2282,7 @@ BgBufferSync(WritebackContext *wb_context)
reusable_buffers++;
if (++num_written >= bgwriter_lru_maxpages)
{
- BgWriterStats.m_maxwritten_clean++;
+ BgWriterStats.maxwritten_clean++;
break;
}
}
@@ -2290,7 +2290,7 @@ BgBufferSync(WritebackContext *wb_context)
reusable_buffers++;
}
- BgWriterStats.m_buf_written_clean += num_written;
+ BgWriterStats.buf_written_clean += num_written;
#ifdef BGW_DEBUG
elog(DEBUG1, "bgwriter: recent_alloc=%u smoothed=%.2f delta=%ld ahead=%d density=%.2f reusable_est=%d
upcoming_est=%dscanned=%d wrote=%d reusable=%d",
diff --git a/src/backend/storage/lmgr/deadlock.c b/src/backend/storage/lmgr/deadlock.c
index aeaf1f3ab4..2b64d313b9 100644
--- a/src/backend/storage/lmgr/deadlock.c
+++ b/src/backend/storage/lmgr/deadlock.c
@@ -1130,7 +1130,7 @@ DeadLockReport(void)
pgstat_get_backend_current_activity(info->pid, false));
}
- pgstat_report_deadlock();
+ pgstat_report_deadlock(false);
ereport(ERROR,
(errcode(ERRCODE_T_R_DEADLOCK_DETECTED),
diff --git a/src/backend/utils/adt/pgstatfuncs.c b/src/backend/utils/adt/pgstatfuncs.c
index e95e347184..6112e04820 100644
--- a/src/backend/utils/adt/pgstatfuncs.c
+++ b/src/backend/utils/adt/pgstatfuncs.c
@@ -33,7 +33,7 @@
#define UINT32_ACCESS_ONCE(var) ((uint32)(*((volatile uint32 *)&(var))))
/* Global bgwriter statistics, from bgwriter.c */
-extern PgStat_MsgBgWriter bgwriterStats;
+extern PgStat_BgWriter bgwriterStats;
Datum
pg_stat_get_numscans(PG_FUNCTION_ARGS)
diff --git a/src/include/pgstat.h b/src/include/pgstat.h
index afc1927250..ff97d6ab6e 100644
--- a/src/include/pgstat.h
+++ b/src/include/pgstat.h
@@ -39,31 +39,6 @@ typedef enum TrackFunctionsLevel
TRACK_FUNC_ALL
} TrackFunctionsLevel;
-/* ----------
- * The types of backend -> collector messages
- * ----------
- */
-typedef enum StatMsgType
-{
- PGSTAT_MTYPE_DUMMY,
- PGSTAT_MTYPE_TABSTAT,
- PGSTAT_MTYPE_TABPURGE,
- PGSTAT_MTYPE_DROPDB,
- PGSTAT_MTYPE_RESETCOUNTER,
- PGSTAT_MTYPE_RESETSHAREDCOUNTER,
- PGSTAT_MTYPE_RESETSINGLECOUNTER,
- PGSTAT_MTYPE_AUTOVAC_START,
- PGSTAT_MTYPE_VACUUM,
- PGSTAT_MTYPE_ANALYZE,
- PGSTAT_MTYPE_ARCHIVER,
- PGSTAT_MTYPE_BGWRITER,
- PGSTAT_MTYPE_FUNCSTAT,
- PGSTAT_MTYPE_FUNCPURGE,
- PGSTAT_MTYPE_RECOVERYCONFLICT,
- PGSTAT_MTYPE_TEMPFILE,
- PGSTAT_MTYPE_DEADLOCK
-} StatMsgType;
-
/* ----------
* The data type used for counters.
* ----------
@@ -112,13 +87,6 @@ typedef struct PgStat_TableCounts
PgStat_Counter t_blocks_hit;
} PgStat_TableCounts;
-/* Possible targets for resetting cluster-wide shared values */
-typedef enum PgStat_Shared_Reset_Target
-{
- RESET_ARCHIVER,
- RESET_BGWRITER
-} PgStat_Shared_Reset_Target;
-
/* Possible object types for resetting single counters */
typedef enum PgStat_Single_Reset_Type
{
@@ -177,242 +145,23 @@ typedef struct PgStat_TableXactStatus
} PgStat_TableXactStatus;
-/* ------------------------------------------------------------
- * Message formats follow
- * ------------------------------------------------------------
- */
-
-
/* ----------
- * PgStat_MsgHdr The common message header
+ * PgStat_BgWriter bgwriter statistics
* ----------
*/
-typedef struct PgStat_MsgHdr
+typedef struct PgStat_BgWriter
{
- 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 loopback interface.
- * (Larger values of PGSTAT_MAX_MSG_SIZE would work for that on most
- * platforms, but we're being conservative here.)
- * ----------
- */
-#define PGSTAT_MAX_MSG_SIZE 1000
-#define PGSTAT_MSG_PAYLOAD (PGSTAT_MAX_MSG_SIZE - sizeof(PgStat_MsgHdr))
-
-
-/* ----------
- * PgStat_MsgDummy A dummy message, ignored by the collector
- * ----------
- */
-typedef struct PgStat_MsgDummy
-{
- PgStat_MsgHdr m_hdr;
-} PgStat_MsgDummy;
-
-/* ----------
- * 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) - 2 * sizeof(PgStat_Counter)) \
- / 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_Counter m_block_read_time; /* times in microseconds */
- PgStat_Counter m_block_write_time;
- 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_MsgResetsharedcounter Sent by the backend to tell the collector
- * to reset a shared counter
- * ----------
- */
-typedef struct PgStat_MsgResetsharedcounter
-{
- PgStat_MsgHdr m_hdr;
- PgStat_Shared_Reset_Target m_resettarget;
-} PgStat_MsgResetsharedcounter;
-
-/* ----------
- * PgStat_MsgResetsinglecounter Sent by the backend to tell the collector
- * to reset a single counter
- * ----------
- */
-typedef struct PgStat_MsgResetsinglecounter
-{
- PgStat_MsgHdr m_hdr;
- Oid m_databaseid;
- PgStat_Single_Reset_Type m_resettype;
- Oid m_objectid;
-} PgStat_MsgResetsinglecounter;
-
-/* ----------
- * 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
- * ----------
- */
-typedef struct PgStat_MsgVacuum
-{
- PgStat_MsgHdr m_hdr;
- Oid m_databaseid;
- Oid m_tableoid;
- bool m_autovacuum;
- TimestampTz m_vacuumtime;
- PgStat_Counter m_live_tuples;
- PgStat_Counter m_dead_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;
- bool m_resetcounter;
- TimestampTz m_analyzetime;
- PgStat_Counter m_live_tuples;
- PgStat_Counter m_dead_tuples;
-} PgStat_MsgAnalyze;
-
-
-/* ----------
- * PgStat_MsgArchiver Sent by the archiver to update statistics.
- * ----------
- */
-typedef struct PgStat_MsgArchiver
-{
- PgStat_MsgHdr m_hdr;
- bool m_failed; /* Failed attempt */
- char m_xlog[MAX_XFN_CHARS + 1];
- TimestampTz m_timestamp;
-} PgStat_MsgArchiver;
-
-/* ----------
- * 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_fsync_backend;
- PgStat_Counter m_buf_alloc;
- PgStat_Counter m_checkpoint_write_time; /* times in milliseconds */
- PgStat_Counter m_checkpoint_sync_time;
-} PgStat_MsgBgWriter;
-
-/* ----------
- * PgStat_MsgRecoveryConflict Sent by the backend upon recovery conflict
- * ----------
- */
-typedef struct PgStat_MsgRecoveryConflict
-{
- PgStat_MsgHdr m_hdr;
-
- Oid m_databaseid;
- int m_reason;
-} PgStat_MsgRecoveryConflict;
-
-/* ----------
- * PgStat_MsgTempFile Sent by the backend upon creating a temp file
- * ----------
- */
-typedef struct PgStat_MsgTempFile
-{
- PgStat_MsgHdr m_hdr;
-
- Oid m_databaseid;
- size_t m_filesize;
-} PgStat_MsgTempFile;
+ 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_fsync_backend;
+ PgStat_Counter buf_alloc;
+ PgStat_Counter checkpoint_write_time; /* times in milliseconds */
+ PgStat_Counter checkpoint_sync_time;
+} PgStat_BgWriter;
/* ----------
* PgStat_FunctionCounts The actual per-function counts kept by a backend
@@ -453,78 +202,6 @@ typedef struct PgStat_FunctionEntry
PgStat_Counter f_self_time;
} 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_MsgDeadlock Sent by the backend to tell the collector
- * about a deadlock that occurred.
- * ----------
- */
-typedef struct PgStat_MsgDeadlock
-{
- PgStat_MsgHdr m_hdr;
- Oid m_databaseid;
-} PgStat_MsgDeadlock;
-
-
-/* ----------
- * PgStat_Msg Union over all possible messages.
- * ----------
- */
-typedef union PgStat_Msg
-{
- PgStat_MsgHdr msg_hdr;
- PgStat_MsgDummy msg_dummy;
- PgStat_MsgTabstat msg_tabstat;
- PgStat_MsgTabpurge msg_tabpurge;
- PgStat_MsgDropdb msg_dropdb;
- PgStat_MsgResetcounter msg_resetcounter;
- PgStat_MsgResetsharedcounter msg_resetsharedcounter;
- PgStat_MsgResetsinglecounter msg_resetsinglecounter;
- PgStat_MsgAutovacStart msg_autovacuum;
- PgStat_MsgVacuum msg_vacuum;
- PgStat_MsgAnalyze msg_analyze;
- PgStat_MsgArchiver msg_archiver;
- PgStat_MsgBgWriter msg_bgwriter;
- PgStat_MsgFuncstat msg_funcstat;
- PgStat_MsgFuncpurge msg_funcpurge;
- PgStat_MsgRecoveryConflict msg_recoveryconflict;
- PgStat_MsgDeadlock msg_deadlock;
-} PgStat_Msg;
-
-
/* ------------------------------------------------------------
* Statistic collector data structures follow
*
@@ -1111,7 +788,7 @@ extern char *pgstat_stat_filename;
/*
* BgWriter statistics counters are updated directly by bgwriter and bufmgr
*/
-extern PgStat_MsgBgWriter BgWriterStats;
+extern PgStat_BgWriter BgWriterStats;
/*
* Updated by pgstat_count_buffer_*_time macros
@@ -1135,8 +812,6 @@ extern void allow_immediate_pgstat_restart(void);
* 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_drop_database(Oid databaseid);
@@ -1154,7 +829,7 @@ extern void pgstat_report_analyze(Relation rel,
bool resetcounter);
extern void pgstat_report_recovery_conflict(int reason);
-extern void pgstat_report_deadlock(void);
+extern void pgstat_report_deadlock(bool pending);
extern void pgstat_initialize(void);
extern void pgstat_bestart(void);
@@ -1328,4 +1003,6 @@ extern void PgstatCollectorMain(void) pg_attribute_noreturn();
extern Size StatsShmemSize(void);
extern void StatsShmemInit(void);
+extern void pgstat_cleanup_pending_stat(void);
+
#endif /* PGSTAT_H */
--
2.16.3
В списке pgsql-hackers по дате отправления:
Предыдущее
От: John NaylorДата:
Сообщение: Re: inconsistency and inefficiency in setup_conversion()
Следующее
От: Amit LangoteДата:
Сообщение: Re: Expression errors with "FOR UPDATE" and postgres_fdw withpartition wise join enabled.