Adjust pgstat_initstats() to avoid repeated searches of the TabStat arrays

when a relation is opened multiple times in the same transaction.  This is
particularly useful for system catalogs, which we may heap_open or index_open
many times in a transaction, and it doesn't really cost anything extra even
if the rel is touched but once.  Motivated by study of an example from Greg
Stark, in which pgstat_initstats() accounted for an unreasonably large
fraction of the runtime.

diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c
index e1699cd0bdf75cf0c908554190889f3c34bb51d7..be9b236d5455c201b6c75592c10f4bde6713296c 100644 (file)
--- a/src/backend/postmaster/pgstat.c
+++ b/src/backend/postmaster/pgstat.c
@@ -13,7 +13,7 @@
  *
  *     Copyright (c) 2001-2007, PostgreSQL Global Development Group
  *
- *     $PostgreSQL: pgsql/src/backend/postmaster/pgstat.c,v 1.152 2007/03/30 18:34:55 mha Exp $
+ *     $PostgreSQL: pgsql/src/backend/postmaster/pgstat.c,v 1.153 2007/04/21 04:10:53 tgl Exp $
  * ----------
  */
 #include "postgres.h"
@@ -114,6 +114,14 @@ static bool pgStatRunningInCollector = false;
  * Place where backends store per-table info to be sent to the collector.
  * We store shared relations separately from non-shared ones, to be able to
  * send them in separate messages.
+ *
+ * NOTE: once allocated, a PgStat_MsgTabstat struct belonging to a
+ * TabStatArray is never moved or deleted for the life of the backend.
+ * Also, we zero out the t_id fields of the contained PgStat_TableEntry
+ * structs whenever they are not actively in use.  This allows PgStat_Info
+ * pointers to be treated as long-lived data, avoiding repeated searches in
+ * pgstat_initstats() when a relation is repeatedly heap_open'd or
+ * index_open'd during a transaction.
  */
 typedef struct TabStatArray
 {
@@ -169,6 +177,7 @@ static void pgstat_write_statsfile(void);
 static HTAB *pgstat_read_statsfile(Oid onlydb);
 static void backend_read_statsfile(void);
 static void pgstat_read_current_status(void);
+static void pgstat_report_one_tabstat(TabStatArray *tsarr, Oid dbid);
 static HTAB *pgstat_collect_oids(Oid catalogid);
 
 static void pgstat_setup_memcxt(void);
@@ -606,25 +615,22 @@ void allow_immediate_pgstat_restart(void)
 void
 pgstat_report_tabstat(void)
 {
-       int                     i;
-
-       if (pgStatSock < 0 ||
-               (!pgstat_collect_tuplelevel &&
-                !pgstat_collect_blocklevel))
-       {
-               /* Not reporting stats, so just flush whatever we have */
-               RegularTabStat.tsa_used = 0;
-               SharedTabStat.tsa_used = 0;
-               return;
-       }
-
        /*
         * For each message buffer used during the last query set the header
-        * fields and send it out.
+        * fields and send it out; then mark the entries unused.
         */
-       for (i = 0; i < RegularTabStat.tsa_used; i++)
+       pgstat_report_one_tabstat(&RegularTabStat, MyDatabaseId);
+       pgstat_report_one_tabstat(&SharedTabStat, InvalidOid);
+}
+
+static void
+pgstat_report_one_tabstat(TabStatArray *tsarr, Oid dbid)
+{
+       int                     i;
+
+       for (i = 0; i < tsarr->tsa_used; i++)
        {
-               PgStat_MsgTabstat *tsmsg = RegularTabStat.tsa_messages[i];
+               PgStat_MsgTabstat *tsmsg = tsarr->tsa_messages[i];
                int                     n;
                int                     len;
 
@@ -637,32 +643,24 @@ pgstat_report_tabstat(void)
                pgStatXactCommit = 0;
                pgStatXactRollback = 0;
 
-               pgstat_setheader(&tsmsg->m_hdr, PGSTAT_MTYPE_TABSTAT);
-               tsmsg->m_databaseid = MyDatabaseId;
-               pgstat_send(tsmsg, len);
-       }
-       RegularTabStat.tsa_used = 0;
-
-       /* Ditto, for shared relations */
-       for (i = 0; i < SharedTabStat.tsa_used; i++)
-       {
-               PgStat_MsgTabstat *tsmsg = SharedTabStat.tsa_messages[i];
-               int                     n;
-               int                     len;
-
-               n = tsmsg->m_nentries;
-               len = offsetof(PgStat_MsgTabstat, m_entry[0]) +
-                       n * sizeof(PgStat_TableEntry);
-
-               /* We don't report transaction commit/abort here */
-               tsmsg->m_xact_commit = 0;
-               tsmsg->m_xact_rollback = 0;
+               /*
+                * It's unlikely we'd get here with no socket, but maybe not
+                * impossible
+                */
+               if (pgStatSock >= 0)
+               {
+                       pgstat_setheader(&tsmsg->m_hdr, PGSTAT_MTYPE_TABSTAT);
+                       tsmsg->m_databaseid = dbid;
+                       pgstat_send(tsmsg, len);
+               }
 
-               pgstat_setheader(&tsmsg->m_hdr, PGSTAT_MTYPE_TABSTAT);
-               tsmsg->m_databaseid = InvalidOid;
-               pgstat_send(tsmsg, len);
+               /*
+                * Zero out the entries, to mark them unused and prepare them
+                * for next use.
+                */
+               MemSet(tsmsg, 0, len);
        }
-       SharedTabStat.tsa_used = 0;
+       tsarr->tsa_used = 0;
 }
 
 
@@ -1013,7 +1011,7 @@ more_tabstat_space(TabStatArray *tsarr)
 
        newAlloc = tsarr->tsa_alloc + TABSTAT_QUANTUM;
 
-       /* Create (another) quantum of message buffers */
+       /* Create (another) quantum of message buffers, and zero them */
        newMessages = (PgStat_MsgTabstat *)
                MemoryContextAllocZero(TopMemoryContext,
                                                           sizeof(PgStat_MsgTabstat) * TABSTAT_QUANTUM);
@@ -1043,6 +1041,17 @@ more_tabstat_space(TabStatArray *tsarr)
  *     of Relation or Scan structures. The data placed into these
  *     structures from here tell where later to count for buffer reads,
  *     scans and tuples fetched.
+ *
+ *     NOTE: PgStat_Info pointers in scan structures are really redundant
+ *     with those in relcache entries.  The passed stats pointer might point
+ *     either to the Relation struct's own pgstat_info field, or to one in
+ *     a scan structure; we'll set the Relation pg_statinfo and copy it to
+ *     the scan struct.
+ *
+ *     We assume that a relcache entry's pgstat_info field is zeroed by
+ *     relcache.c when the relcache entry is made; thereafter it is long-lived
+ *     data.  We can avoid repeated searches of the TabStat arrays when the
+ *     same relation is touched repeatedly within a transaction.
  * ----------
  */
 void
@@ -1055,21 +1064,31 @@ pgstat_initstats(PgStat_Info *stats, Relation rel)
        int                     mb;
        int                     i;
 
-       /*
-        * Initialize data not to count at all.
-        */
-       stats->tabentry = NULL;
-
        if (pgStatSock < 0 ||
                !(pgstat_collect_tuplelevel ||
                  pgstat_collect_blocklevel))
+       {
+               /* We're not counting at all. */
+               stats->tabentry = NULL;
                return;
+       }
 
-       tsarr = rel->rd_rel->relisshared ? &SharedTabStat : &RegularTabStat;
+       /*
+        * If we already set up this relation in the current transaction,
+        * just copy the pointer.
+        */
+       if (rel->pgstat_info.tabentry != NULL &&
+               ((PgStat_TableEntry *) rel->pgstat_info.tabentry)->t_id == rel_id)
+       {
+               stats->tabentry = rel->pgstat_info.tabentry;
+               return;
+       }
 
        /*
         * Search the already-used message slots for this relation.
         */
+       tsarr = rel->rd_rel->relisshared ? &SharedTabStat : &RegularTabStat;
+
        for (mb = 0; mb < tsarr->tsa_used; mb++)
        {
                tsmsg = tsarr->tsa_messages[mb];
@@ -1078,7 +1097,8 @@ pgstat_initstats(PgStat_Info *stats, Relation rel)
                {
                        if (tsmsg->m_entry[i].t_id == rel_id)
                        {
-                               stats->tabentry = (void *) &(tsmsg->m_entry[i]);
+                               rel->pgstat_info.tabentry = (void *) &(tsmsg->m_entry[i]);
+                               stats->tabentry = rel->pgstat_info.tabentry;
                                return;
                        }
                }
@@ -1088,13 +1108,14 @@ pgstat_initstats(PgStat_Info *stats, Relation rel)
 
                /*
                 * Not found, but found a message buffer with an empty slot instead.
-                * Fine, let's use this one.
+                * Fine, let's use this one.  We assume the entry was already zeroed,
+                * either at creation or after last use.
                 */
                i = tsmsg->m_nentries++;
                useent = &tsmsg->m_entry[i];
-               MemSet(useent, 0, sizeof(PgStat_TableEntry));
                useent->t_id = rel_id;
-               stats->tabentry = (void *) useent;
+               rel->pgstat_info.tabentry = (void *) useent;
+               stats->tabentry = rel->pgstat_info.tabentry;
                return;
        }
 
@@ -1111,9 +1132,9 @@ pgstat_initstats(PgStat_Info *stats, Relation rel)
        tsmsg = tsarr->tsa_messages[mb];
        tsmsg->m_nentries = 1;
        useent = &tsmsg->m_entry[0];
-       MemSet(useent, 0, sizeof(PgStat_TableEntry));
        useent->t_id = rel_id;
-       stats->tabentry = (void *) useent;
+       rel->pgstat_info.tabentry = (void *) useent;
+       stats->tabentry = rel->pgstat_info.tabentry;
 }